@zapier/zapier-sdk 0.33.0 → 0.33.2

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

@@ -1,346 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { groupVersionedAppKeysByType, groupAppKeysByType, toAppLocator, } from "./domain-utils";
-describe("domain-utils", () => {
-    describe("groupVersionedAppKeysByType", () => {
-        it("should reject UUID app keys", () => {
-            expect(() => {
-                groupVersionedAppKeysByType(["61e47557-af91-4b0c-a3e0-c28606357664"]);
-            }).toThrow("UUID app keys are not supported. Use app slug or implementation ID instead of: 61e47557-af91-4b0c-a3e0-c28606357664");
-        });
-        it("should categorize *API as selectedApi", () => {
-            const result = groupVersionedAppKeysByType(["FormatterCLIAPI"]);
-            expect(result).toEqual({
-                selectedApi: ["FormatterCLIAPI"],
-                slug: [],
-            });
-        });
-        it("should categorize various API types as selectedApi", () => {
-            const result = groupVersionedAppKeysByType([
-                "FormatterCLIAPI",
-                "SlackAPI",
-                "GmailRESTAPI",
-                "WebhookAPI",
-                "AnythingWithUppercase",
-            ]);
-            expect(result).toEqual({
-                selectedApi: [
-                    "FormatterCLIAPI",
-                    "SlackAPI",
-                    "GmailRESTAPI",
-                    "WebhookAPI",
-                    "AnythingWithUppercase",
-                ],
-                slug: [],
-            });
-        });
-        it("should categorize lower-case strings as slugs, converting underscores to dashes", () => {
-            const result = groupVersionedAppKeysByType([
-                "slack",
-                "google-sheets",
-                "_100hires_ats",
-                "amazon_redshift",
-            ]);
-            expect(result).toEqual({
-                selectedApi: [],
-                slug: ["slack", "google-sheets", "100hires-ats", "amazon-redshift"],
-            });
-        });
-        it("should preserve version from API implementations", () => {
-            const result = groupVersionedAppKeysByType(["FormatterCLIAPI@1.0.0"]);
-            expect(result).toEqual({
-                selectedApi: ["FormatterCLIAPI@1.0.0"],
-                slug: [],
-            });
-        });
-        it("should preserve version from slugs", () => {
-            const result = groupVersionedAppKeysByType(["slack@2.1.0"]);
-            expect(result).toEqual({
-                selectedApi: [],
-                slug: ["slack@2.1.0"],
-            });
-        });
-        it("should handle mixed types correctly", () => {
-            const result = groupVersionedAppKeysByType([
-                "FormatterCLIAPI@1.0.0",
-                "slack",
-                "AnotherAPI",
-                "gmail@3.0.1",
-            ]);
-            expect(result).toEqual({
-                selectedApi: ["FormatterCLIAPI@1.0.0", "AnotherAPI"],
-                slug: ["slack", "gmail@3.0.1"],
-            });
-        });
-        it("should handle empty array", () => {
-            const result = groupVersionedAppKeysByType([]);
-            expect(result).toEqual({
-                selectedApi: [],
-                slug: [],
-            });
-        });
-        it("should reject uppercase and lowercase UUIDs", () => {
-            expect(() => {
-                groupVersionedAppKeysByType(["61E47557-AF91-4B0C-A3E0-C28606357664"]);
-            }).toThrow("UUID app keys are not supported. Use app slug or implementation ID instead of: 61E47557-AF91-4B0C-A3E0-C28606357664");
-            expect(() => {
-                groupVersionedAppKeysByType(["f47ac10b-58cc-4372-a567-0e02b2c3d479"]);
-            }).toThrow("UUID app keys are not supported. Use app slug or implementation ID instead of: f47ac10b-58cc-4372-a567-0e02b2c3d479");
-        });
-        it("should categorize partial UUIDs as slugs", () => {
-            const result = groupVersionedAppKeysByType([
-                "61e47557-af91-4b0c-a3e0", // too short
-                "61e47557-af91-4b0c-a3e0-c28606357664-extra", // too long
-            ]);
-            expect(result).toEqual({
-                selectedApi: [],
-                slug: [
-                    "61e47557-af91-4b0c-a3e0",
-                    "61e47557-af91-4b0c-a3e0-c28606357664-extra",
-                ],
-            });
-        });
-        it("should dedupe exact duplicate versioned keys", () => {
-            const result = groupVersionedAppKeysByType([
-                "slack@2.1.0",
-                "FormatterCLIAPI@1.0.0",
-                "slack@2.1.0", // exact duplicate
-                "FormatterCLIAPI@1.0.0", // exact duplicate
-                "slack@2.1.1",
-                "FormatterCLIAPI@1.0.1",
-            ]);
-            expect(result).toEqual({
-                selectedApi: ["FormatterCLIAPI@1.0.0", "FormatterCLIAPI@1.0.1"],
-                slug: ["slack@2.1.0", "slack@2.1.1"],
-            });
-        });
-    });
-    describe("groupAppKeysByType", () => {
-        it("should strip versions from API implementations", () => {
-            const result = groupAppKeysByType(["FormatterCLIAPI@1.0.0"]);
-            expect(result).toEqual({
-                selectedApi: ["FormatterCLIAPI"],
-                slug: [],
-            });
-        });
-        it("should strip versions from slugs", () => {
-            const result = groupAppKeysByType(["slack@2.1.0"]);
-            expect(result).toEqual({
-                selectedApi: [],
-                slug: ["slack"],
-            });
-        });
-        it("should handle mixed types and strip versions", () => {
-            const result = groupAppKeysByType([
-                "FormatterCLIAPI@1.0.0",
-                "slack",
-                "AnotherAPI@2.3.4",
-                "gmail@3.0.1",
-            ]);
-            expect(result).toEqual({
-                selectedApi: ["FormatterCLIAPI", "AnotherAPI"],
-                slug: ["slack", "gmail"],
-            });
-        });
-        it("should handle keys without versions", () => {
-            const result = groupAppKeysByType([
-                "FormatterCLIAPI",
-                "slack",
-                "AnotherAPI",
-            ]);
-            expect(result).toEqual({
-                selectedApi: ["FormatterCLIAPI", "AnotherAPI"],
-                slug: ["slack"],
-            });
-        });
-        it("should reject UUID app keys (delegated to versioned function)", () => {
-            expect(() => {
-                groupAppKeysByType(["61e47557-af91-4b0c-a3e0-c28606357664"]);
-            }).toThrow("UUID app keys are not supported. Use app slug or implementation ID instead of: 61e47557-af91-4b0c-a3e0-c28606357664");
-        });
-        it("should handle empty array", () => {
-            const result = groupAppKeysByType([]);
-            expect(result).toEqual({
-                selectedApi: [],
-                slug: [],
-            });
-        });
-        it("should dedupe multiple versions of same base key", () => {
-            const result = groupAppKeysByType([
-                "slack@1.0.0",
-                "FormatterCLIAPI@2.1.0",
-                "slack@1.2.3", // different version of slack
-                "FormatterCLIAPI@1.0.0", // different version of FormatterCLIAPI
-                "gmail",
-            ]);
-            expect(result).toEqual({
-                selectedApi: ["FormatterCLIAPI"], // only one instance despite multiple versions
-                slug: ["slack", "gmail"], // only one slack despite multiple versions
-            });
-        });
-        it("should dedupe exact duplicates after version stripping", () => {
-            const result = groupAppKeysByType([
-                "slack@1.0.0",
-                "slack", // no version
-                "slack@2.0.0", // different version
-                "FormatterCLIAPI",
-                "FormatterCLIAPI@1.5.0",
-            ]);
-            expect(result).toEqual({
-                selectedApi: ["FormatterCLIAPI"],
-                slug: ["slack"],
-            });
-        });
-    });
-    describe("toAppLocator", () => {
-        it("should reject UUID app keys", () => {
-            expect(() => {
-                toAppLocator("61e47557-af91-4b0c-a3e0-c28606357664");
-            }).toThrow("UUID app keys are not supported. Use app slug or implementation ID instead of: 61e47557-af91-4b0c-a3e0-c28606357664");
-        });
-        it("should reject UUID app keys with versions", () => {
-            expect(() => {
-                toAppLocator("61e47557-af91-4b0c-a3e0-c28606357664@1.0.0");
-            }).toThrow("UUID app keys are not supported. Use app slug or implementation ID instead of: 61e47557-af91-4b0c-a3e0-c28606357664@1.0.0");
-        });
-        it("should reject uppercase UUID app keys", () => {
-            expect(() => {
-                toAppLocator("61E47557-AF91-4B0C-A3E0-C28606357664");
-            }).toThrow("UUID app keys are not supported. Use app slug or implementation ID instead of: 61E47557-AF91-4B0C-A3E0-C28606357664");
-        });
-        it("should handle simple slug without version", () => {
-            const result = toAppLocator("slack");
-            expect(result).toEqual({
-                lookupAppKey: "slack",
-                slug: "slack",
-                implementationName: undefined,
-                version: undefined,
-            });
-        });
-        it("should handle slug with version", () => {
-            const result = toAppLocator("slack@1.0.0");
-            expect(result).toEqual({
-                lookupAppKey: "slack",
-                slug: "slack",
-                implementationName: undefined,
-                version: "1.0.0",
-            });
-        });
-        it("should handle dashified slug", () => {
-            const result = toAppLocator("google-sheets");
-            expect(result).toEqual({
-                lookupAppKey: "google-sheets",
-                slug: "google-sheets",
-                implementationName: undefined,
-                version: undefined,
-            });
-        });
-        it("should handle dashified slug with version", () => {
-            const result = toAppLocator("google-sheets@2.1.3");
-            expect(result).toEqual({
-                lookupAppKey: "google-sheets",
-                slug: "google-sheets",
-                implementationName: undefined,
-                version: "2.1.3",
-            });
-        });
-        it("should handle snake_cased slug and convert to dash", () => {
-            const result = toAppLocator("google_sheets");
-            expect(result).toEqual({
-                lookupAppKey: "google_sheets",
-                slug: "google-sheets",
-                implementationName: undefined,
-                version: undefined,
-            });
-        });
-        it("should handle snake_cased slug with version and convert to dash", () => {
-            const result = toAppLocator("google_sheets@2.1.3");
-            expect(result).toEqual({
-                lookupAppKey: "google_sheets",
-                slug: "google-sheets",
-                implementationName: undefined,
-                version: "2.1.3",
-            });
-        });
-        it("should handle leading underscore snake_cased slug", () => {
-            const result = toAppLocator("_100hires_ats");
-            expect(result).toEqual({
-                lookupAppKey: "_100hires_ats",
-                slug: "100hires-ats",
-                implementationName: undefined,
-                version: undefined,
-            });
-        });
-        it("should handle leading underscore snake_cased slug with version", () => {
-            const result = toAppLocator("_100hires_ats@3.0.0");
-            expect(result).toEqual({
-                lookupAppKey: "_100hires_ats",
-                slug: "100hires-ats",
-                implementationName: undefined,
-                version: "3.0.0",
-            });
-        });
-        it("should handle implementation name without version", () => {
-            const result = toAppLocator("SlackCLIAPI");
-            expect(result).toEqual({
-                lookupAppKey: "SlackCLIAPI",
-                slug: undefined,
-                implementationName: "SlackCLIAPI",
-                version: undefined,
-            });
-        });
-        it("should handle implementation name with version", () => {
-            const result = toAppLocator("SlackCLIAPI@1.29.0");
-            expect(result).toEqual({
-                lookupAppKey: "SlackCLIAPI",
-                slug: undefined,
-                implementationName: "SlackCLIAPI",
-                version: "1.29.0",
-            });
-        });
-        it("should handle edge cases with complex version numbers", () => {
-            const result = toAppLocator("slack@1.2.3-beta.4+build.5");
-            expect(result).toEqual({
-                lookupAppKey: "slack",
-                slug: "slack",
-                implementationName: undefined,
-                version: "1.2.3-beta.4+build.5",
-            });
-        });
-        it("should handle single character app keys", () => {
-            const result = toAppLocator("a");
-            expect(result).toEqual({
-                lookupAppKey: "a",
-                slug: "a",
-                implementationName: undefined,
-                version: undefined,
-            });
-        });
-        it("should handle app keys with numbers", () => {
-            const result = toAppLocator("app123");
-            expect(result).toEqual({
-                lookupAppKey: "app123",
-                slug: "app123",
-                implementationName: undefined,
-                version: undefined,
-            });
-        });
-        it("should handle mixed case app keys that aren't implementation names", () => {
-            const result = toAppLocator("SlackBot");
-            expect(result).toEqual({
-                lookupAppKey: "SlackBot",
-                slug: undefined,
-                implementationName: "SlackBot",
-                version: undefined,
-            });
-        });
-        it("should handle empty version (app key ending with @)", () => {
-            const result = toAppLocator("slack@");
-            expect(result).toEqual({
-                lookupAppKey: "slack",
-                slug: "slack",
-                implementationName: undefined,
-                version: "",
-            });
-        });
-    });
-});

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

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

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

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

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

@@ -1,51 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { resolve, writeFile, readFile } from "./file-utils";
-// Mock the dynamic imports to simulate missing modules
-vi.mock("fs/promises", () => {
-    throw new Error("Module not found");
-});
-vi.mock("path", () => {
-    throw new Error("Module not found");
-});
-describe("file-utils", () => {
-    describe("resolve", () => {
-        it("should handle absolute paths", async () => {
-            expect(await resolve("/absolute/path")).toBe("/absolute/path");
-        });
-        it("should handle relative paths with ./", async () => {
-            expect(await resolve("./relative/path")).toBe("/relative/path");
-            expect(await resolve("./relative/path", "/base")).toBe("/base/relative/path");
-            expect(await resolve("./relative/path", "/base/")).toBe("/base/relative/path");
-        });
-        it("should handle parent directory paths with ../", async () => {
-            expect(await resolve("../parent/path")).toBe("/parent/path");
-            expect(await resolve("../../nested/parent/path")).toBe("/nested/parent/path");
-            expect(await resolve("../parent/path", "/base")).toBe("/base/parent/path");
-        });
-        it("should handle paths without prefix", async () => {
-            expect(await resolve("simple/path")).toBe("/simple/path");
-            expect(await resolve("simple/path", "/base")).toBe("/base/simple/path");
-            expect(await resolve("simple/path", "/base/")).toBe("/base/simple/path");
-        });
-    });
-    describe("writeFile and readFile with in-memory filesystem", () => {
-        it("should write and read files using in-memory filesystem when fs is not available", async () => {
-            const filePath = "/test/file.txt";
-            const content = "Hello, world!";
-            await writeFile(filePath, content);
-            const readContent = await readFile(filePath);
-            expect(readContent).toBe(content);
-        });
-        it("should throw error when reading non-existent file", async () => {
-            await expect(readFile("/non/existent/file.txt")).rejects.toThrow("File not found: /non/existent/file.txt");
-        });
-        it("should handle multiple files in in-memory filesystem", async () => {
-            await writeFile("/file1.txt", "content1");
-            await writeFile("/file2.txt", "content2");
-            await writeFile("/dir/file3.txt", "content3");
-            expect(await readFile("/file1.txt")).toBe("content1");
-            expect(await readFile("/file2.txt")).toBe("content2");
-            expect(await readFile("/dir/file3.txt")).toBe("content3");
-        });
-    });
-});

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

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

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

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

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

@@ -1,188 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { createFunction, createPaginatedFunction } from "./function-utils";
-import { ZapierValidationError, ZapierUnknownError } from "../types/errors";
-import { ALL_ITEMS, listTestItems } from "./pagination-utils.test";
-import { isTelemetryNested } from "./telemetry-context";
-describe("createFunction", () => {
-    it("should return result from core function", async () => {
-        const mockCoreFn = async (options) => {
-            return `Hello, ${options.name}!`;
-        };
-        const wrappedFn = createFunction(mockCoreFn);
-        const result = await wrappedFn({ name: "World" });
-        expect(result).toBe("Hello, World!");
-    });
-});
-describe.each([
-    { name: "createFunction", createFn: createFunction },
-    { name: "createPaginatedFunction", createFn: createPaginatedFunction },
-])("$name", ({ createFn }) => {
-    it("should preserve function name", async () => {
-        async function testCoreFn(options) {
-            return options.value * 2;
-        }
-        const wrappedFn = createFn(testCoreFn);
-        expect(wrappedFn.name).toBe("testCoreFn");
-    });
-    it("should normalize and rethrow ZapierError instances", async () => {
-        const mockError = new ZapierValidationError("Validation failed", {
-            details: { field: "name" },
-        });
-        const mockCoreFn = async () => {
-            throw mockError;
-        };
-        const wrappedFn = createFn(mockCoreFn);
-        await expect(wrappedFn({})).rejects.toBe(mockError);
-    });
-    it("should normalize generic Error to ZapierUnknownError", async () => {
-        const mockCoreFn = async () => {
-            throw new Error("Something went wrong");
-        };
-        const wrappedFn = createFn(mockCoreFn);
-        await expect(wrappedFn({})).rejects.toThrow(ZapierUnknownError);
-    });
-    it("should normalize non-Error values to ZapierUnknownError", async () => {
-        const mockCoreFn = async () => {
-            throw "String error";
-        };
-        const wrappedFn = createFn(mockCoreFn);
-        await expect(wrappedFn({})).rejects.toThrow(ZapierUnknownError);
-    });
-});
-describe("createPaginatedFunction", () => {
-    it("should wrap non-array result in {data: [result]}", async () => {
-        const mockCoreFn = async (options) => {
-            return `Hello, ${options.name}!`;
-        };
-        const wrappedFn = createPaginatedFunction(mockCoreFn);
-        const result = await wrappedFn({ name: "World" });
-        expect(result).toEqual({ data: ["Hello, World!"] });
-    });
-    it("should wrap array result in {data: result}", async () => {
-        const mockCoreFn = async (options) => {
-            return Array.from({ length: options.count }, (_, i) => `Item ${i + 1}`);
-        };
-        const wrappedFn = createPaginatedFunction(mockCoreFn);
-        const result = await wrappedFn({ count: 3 });
-        expect(result).toEqual({ data: ["Item 1", "Item 2", "Item 3"] });
-    });
-    it("should return {data} object unchanged", async () => {
-        const mockCoreFn = async (options) => {
-            return { data: options.items };
-        };
-        const wrappedFn = createPaginatedFunction(mockCoreFn);
-        const result = await wrappedFn({ items: ["A", "B", "C"] });
-        expect(result).toEqual({ data: ["A", "B", "C"] });
-    });
-    it("should allow for await iteration over pages", async () => {
-        const listItems = createPaginatedFunction(listTestItems);
-        const pages = [];
-        for await (const page of listItems({ pageSize: 3 })) {
-            pages.push(page);
-            if (pages.length >= 3)
-                break;
-        }
-        // Should have collected 3 pages
-        expect(pages).toHaveLength(3);
-        // Check first page structure
-        expect(pages[0]).toEqual({
-            data: ALL_ITEMS.slice(0, 3),
-            nextCursor: "cursor-3",
-        });
-        // Check second page
-        expect(pages[1]).toEqual({
-            data: ALL_ITEMS.slice(3, 6),
-            nextCursor: "cursor-6",
-        });
-    });
-    it("should allow for await iteration over individual items", async () => {
-        const listItems = createPaginatedFunction(listTestItems);
-        const items = [];
-        for await (const item of listItems({ pageSize: 3 }).items()) {
-            items.push(item);
-            if (items.length >= 7)
-                break; // Get first 7 items across pages
-        }
-        // Should have collected 7 individual items
-        expect(items).toHaveLength(7);
-        // Should be the first 7 items from ALL_ITEMS (flattened from pages)
-        expect(items).toEqual(ALL_ITEMS.slice(0, 7));
-    });
-});
-describe("telemetry nesting via AsyncLocalStorage", () => {
-    it("emits telemetry for a top-level createFunction call", async () => {
-        const onMethodCalled = vi.fn();
-        const telemetry = { onMethodCalled };
-        async function myMethod(options) {
-            return options.value * 2;
-        }
-        const wrapped = createFunction(myMethod, undefined, telemetry);
-        await wrapped({ value: 5 });
-        expect(onMethodCalled).toHaveBeenCalledOnce();
-        expect(onMethodCalled).toHaveBeenCalledWith(expect.objectContaining({
-            methodName: "myMethod",
-            success: true,
-            isPaginated: false,
-        }));
-    });
-    it("emits telemetry for a top-level createPaginatedFunction call", async () => {
-        const onMethodCalled = vi.fn();
-        const wrapped = createPaginatedFunction(listTestItems, undefined, { onMethodCalled }, "topLevelList");
-        await wrapped({ pageSize: 3 });
-        expect(onMethodCalled).toHaveBeenCalledOnce();
-        expect(onMethodCalled).toHaveBeenCalledWith(expect.objectContaining({
-            methodName: "topLevelList",
-            success: true,
-            isPaginated: true,
-        }));
-    });
-    it("suppresses telemetry when createFunction calls another createFunction", async () => {
-        const outerTelemetry = vi.fn();
-        const innerTelemetry = vi.fn();
-        async function innerMethod(_options) {
-            return "inner";
-        }
-        const wrappedInner = createFunction(innerMethod, undefined, {
-            onMethodCalled: innerTelemetry,
-        });
-        async function outerMethod(_options) {
-            return wrappedInner({});
-        }
-        const wrappedOuter = createFunction(outerMethod, undefined, {
-            onMethodCalled: outerTelemetry,
-        });
-        await wrappedOuter({});
-        expect(outerTelemetry).toHaveBeenCalledOnce();
-        expect(innerTelemetry).not.toHaveBeenCalled();
-    });
-    it("suppresses telemetry for nested createPaginatedFunction calls", async () => {
-        const outerTelemetry = vi.fn();
-        const innerTelemetry = vi.fn();
-        const wrappedInner = createPaginatedFunction(listTestItems, undefined, { onMethodCalled: innerTelemetry }, "innerList");
-        async function outerMethod(_options) {
-            const result = await wrappedInner({ pageSize: 3 });
-            return result.data;
-        }
-        const wrappedOuter = createFunction(outerMethod, undefined, {
-            onMethodCalled: outerTelemetry,
-        });
-        await wrappedOuter({});
-        expect(outerTelemetry).toHaveBeenCalledOnce();
-        expect(innerTelemetry).not.toHaveBeenCalled();
-    });
-    it("context is restored after nested call completes", async () => {
-        expect(isTelemetryNested()).toBe(false);
-        async function inner(_options) {
-            return "inner";
-        }
-        const wrappedInner = createFunction(inner);
-        async function outer(_options) {
-            await wrappedInner({});
-            expect(isTelemetryNested()).toBe(false);
-            return "outer";
-        }
-        const wrappedOuter = createFunction(outer);
-        await wrappedOuter({});
-        expect(isTelemetryNested()).toBe(false);
-    });
-});

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

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

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

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

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

@@ -1,22 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { coerceToNumericId } from "./id-utils";
-import { ZapierValidationError } from "../types/errors";
-describe("coerceToNumericId", () => {
-    it("should return number unchanged", () => {
-        expect(coerceToNumericId("test_id", 123)).toBe(123);
-    });
-    it("should convert string number to number", () => {
-        expect(coerceToNumericId("test_id", "456")).toBe(456);
-    });
-    it("should throw for non-numeric string", () => {
-        expect(() => coerceToNumericId("auth_id", "abc")).toThrow(ZapierValidationError);
-        expect(() => coerceToNumericId("auth_id", "abc")).toThrow('The auth_id "abc" could not be converted to a number');
-    });
-    it("should throw for empty string", () => {
-        expect(() => coerceToNumericId("test_id", "")).toThrow(ZapierValidationError);
-        expect(() => coerceToNumericId("test_id", "")).toThrow("The test_id cannot be empty");
-    });
-    it("should throw for Infinity", () => {
-        expect(() => coerceToNumericId("test_id", Infinity)).toThrow(ZapierValidationError);
-    });
-});

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

@@ -1,17 +0,0 @@
-export declare const ALL_ITEMS: {
-    id: number;
-    name: string;
-}[];
-export declare function listTestItems(options: {
-    pageSize?: number;
-    cursor?: string;
-    filter?: string;
-    maxItems?: number;
-}): Promise<{
-    data: {
-        id: number;
-        name: string;
-    }[];
-    nextCursor: string | undefined;
-}>;
-//# sourceMappingURL=pagination-utils.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pagination-utils.test.d.ts","sourceRoot":"","sources":["../../src/utils/pagination-utils.test.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,SAAS;;;GAGnB,CAAC;AAGJ,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;;;;;;GA6CA"}