@zapier/zapier-sdk 0.18.4 → 0.19.0

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.d.ts

@@ -1,73 +0,0 @@
-/**
- * Generic utility functions for creating paginated SDK functions
- */
-import { z } from "zod";
-/**
- * Zod schema for telemetry marker to prevent nested telemetry emissions.
- * Used to extend options schemas with proper typing.
- */
-export declare const TelemetryMarkerSchema: z.ZodObject<{
-    _telemetry: z.ZodOptional<z.ZodObject<{
-        isNested: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-/**
- * Marker for SDK method calls to control telemetry behavior
- */
-export type TelemetryMarker = z.infer<typeof TelemetryMarkerSchema>;
-/**
- * Callbacks for telemetry events during function execution
- */
-export interface TelemetryCallbacks {
-    onMethodCalled?: (data: {
-        methodName: string;
-        durationMs: number;
-        success: boolean;
-        error?: Error;
-        argumentCount: number;
-        isPaginated: boolean;
-    }) => void;
-}
-/**
- * Helper function to extract cursor from pagination data
- * Supports JSON:API style `links.next` URLs by extracting the `offset` parameter.
- */
-export declare function extractCursor(data: {
-    next?: string | null;
-} | null | undefined): string | undefined;
-/**
- * Higher-order function that creates a function from a core function
- *
- * @param coreFn - Function that returns T directly or throws errors
- * @param schema - Optional Zod schema for validation
- * @param telemetry - Optional telemetry callbacks
- * @returns A function that normalizes and rethrows errors
- */
-export declare function createFunction<TOptions, TResult, TSchemaOptions extends TOptions = TOptions>(coreFn: (options: TOptions) => Promise<TResult>, schema?: z.ZodSchema<TSchemaOptions>, telemetry?: TelemetryCallbacks): (options?: TOptions) => Promise<TResult>;
-/**
- * Higher-order function that creates a paginated function that wraps results in {data}
- *
- * @param coreFn - Function that returns T directly or throws errors
- * @returns A function that normalizes errors and wraps results in {data}
- */
-type PaginatedResult<TResult> = TResult extends {
-    data: any;
-    nextCursor?: string;
-} ? TResult : {
-    data: TResult;
-    nextCursor?: string;
-};
-type ItemType<TResult> = TResult extends {
-    data: infer TData;
-} ? TData extends readonly (infer TItem)[] ? TItem : TData : TResult extends readonly (infer TItem)[] ? TItem : TResult;
-export declare function createPaginatedFunction<TOptions, TResult, TSchemaOptions extends TOptions = TOptions>(coreFn: (options: TOptions & {
-    pageSize: number;
-}) => Promise<TResult>, schema?: z.ZodSchema<TSchemaOptions>, telemetry?: TelemetryCallbacks, explicitFunctionName?: string): (options?: TOptions & {
-    cursor?: string;
-    pageSize?: number;
-    maxItems?: number;
-}) => Promise<PaginatedResult<TResult>> & AsyncIterable<PaginatedResult<TResult>> & {
-    items(): AsyncIterable<ItemType<TResult>>;
-};
-export {};
-//# sourceMappingURL=function-utils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"function-utils.d.ts","sourceRoot":"","sources":["../../src/utils/function-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;iBAMhC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE;QACtB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,OAAO,CAAC;QACjB,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,OAAO,CAAC;KACtB,KAAK,IAAI,CAAC;CACZ;AAUD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,GAChD,MAAM,GAAG,SAAS,CAYpB;AAcD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EACR,OAAO,EACP,cAAc,SAAS,QAAQ,GAAG,QAAQ,EAE1C,MAAM,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,OAAO,CAAC,EAC/C,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,EACpC,SAAS,CAAC,EAAE,kBAAkB,cAMc,QAAQ,KAAG,OAAO,CAAC,OAAO,CAAC,CAsExE;AA6DD;;;;;GAKG;AACH,KAAK,eAAe,CAAC,OAAO,IAAI,OAAO,SAAS;IAC9C,IAAI,EAAE,GAAG,CAAC;IACV,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GACG,OAAO,GACP;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3C,KAAK,QAAQ,CAAC,OAAO,IAAI,OAAO,SAAS;IAAE,IAAI,EAAE,MAAM,KAAK,CAAA;CAAE,GAC1D,KAAK,SAAS,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,GACpC,KAAK,GACL,KAAK,GACP,OAAO,SAAS,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,GACtC,KAAK,GACL,OAAO,CAAC;AAEd,wBAAgB,uBAAuB,CACrC,QAAQ,EACR,OAAO,EACP,cAAc,SAAS,QAAQ,GAAG,QAAQ,EAE1C,MAAM,EAAE,CAAC,OAAO,EAAE,QAAQ,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,CAAC,OAAO,CAAC,EACtE,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,EACpC,SAAS,CAAC,EAAE,kBAAkB,EAC9B,oBAAoB,CAAC,EAAE,MAAM,GAC5B,CACD,OAAO,CAAC,EAAE,QAAQ,GAAG;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,KACE,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,GACpC,aAAa,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,GAAG;IACxC,KAAK,IAAI,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;CAC3C,CAgHF"}

package/dist/utils/function-utils.js

@@ -1,245 +0,0 @@
-/**
- * Generic utility functions for creating paginated SDK functions
- */
-import { z } from "zod";
-import { ZapierError, ZapierUnknownError } from "../types/errors";
-import { paginate } from "./pagination-utils";
-import { createValidator, validateOptions } from "./validation";
-/**
- * Zod schema for telemetry marker to prevent nested telemetry emissions.
- * Used to extend options schemas with proper typing.
- */
-export const TelemetryMarkerSchema = z.object({
-    _telemetry: z
-        .object({
-        isNested: z.boolean().optional(),
-    })
-        .optional(),
-});
-/**
- * Helper function to extract cursor from pagination data
- * Supports JSON:API style `links.next` URLs by extracting the `offset` parameter.
- */
-export function extractCursor(data) {
-    if (!data?.next) {
-        return undefined;
-    }
-    try {
-        const urlObj = new URL(data.next);
-        const offset = urlObj.searchParams.get("offset");
-        return offset || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Helper function to convert unknown errors to SDK errors
- */
-function normalizeError(error) {
-    if (error instanceof ZapierError) {
-        return error;
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return new ZapierUnknownError(`Unknown error: ${message}`, { cause: error });
-}
-/**
- * Higher-order function that creates a function from a core function
- *
- * @param coreFn - Function that returns T directly or throws errors
- * @param schema - Optional Zod schema for validation
- * @param telemetry - Optional telemetry callbacks
- * @returns A function that normalizes and rethrows errors
- */
-export function createFunction(coreFn, schema, telemetry) {
-    const functionName = coreFn.name;
-    // Create a named function using dynamic property access
-    const namedFunctions = {
-        [functionName]: async function (options) {
-            const startTime = Date.now();
-            const normalizedOptions = (options ?? {});
-            const isNested = normalizedOptions?._telemetry?.isNested === true;
-            try {
-                if (schema) {
-                    const validatedOptions = validateOptions(schema, normalizedOptions);
-                    const result = await coreFn({
-                        ...normalizedOptions,
-                        ...validatedOptions,
-                    });
-                    // Emit telemetry only for top-level calls
-                    if (!isNested && telemetry?.onMethodCalled) {
-                        const argumentCount = Object.keys(normalizedOptions).filter((k) => k !== "_telemetry").length;
-                        telemetry.onMethodCalled({
-                            methodName: functionName,
-                            durationMs: Date.now() - startTime,
-                            success: true,
-                            argumentCount,
-                            isPaginated: false,
-                        });
-                    }
-                    return result;
-                }
-                const result = await coreFn(normalizedOptions);
-                if (!isNested && telemetry?.onMethodCalled) {
-                    const argumentCount = Object.keys(normalizedOptions).filter((k) => k !== "_telemetry").length;
-                    telemetry.onMethodCalled({
-                        methodName: functionName,
-                        durationMs: Date.now() - startTime,
-                        success: true,
-                        argumentCount,
-                        isPaginated: false,
-                    });
-                }
-                return result;
-            }
-            catch (error) {
-                const normalizedError = normalizeError(error);
-                if (!isNested && telemetry?.onMethodCalled) {
-                    const argumentCount = Object.keys(normalizedOptions).filter((k) => k !== "_telemetry").length;
-                    telemetry.onMethodCalled({
-                        methodName: functionName,
-                        durationMs: Date.now() - startTime,
-                        success: false,
-                        error: normalizedError,
-                        argumentCount,
-                        isPaginated: false,
-                    });
-                }
-                throw normalizedError;
-            }
-        },
-    };
-    return namedFunctions[functionName];
-}
-/**
- * Higher-order function that creates a page function that wraps results in {data}
- * Internal utility used by createPaginatedFunction
- */
-function createPageFunction(coreFn) {
-    const functionName = coreFn.name + "Page";
-    // Create a named function using dynamic property access
-    const namedFunctions = {
-        [functionName]: async function (options) {
-            try {
-                const result = await coreFn(options);
-                // If result already has a data property, ensure it's an array
-                if (result && typeof result === "object" && "data" in result) {
-                    const paginatedResult = result;
-                    // Support both nextCursor and JSON:API links.next format
-                    let nextCursor;
-                    if (paginatedResult.nextCursor) {
-                        nextCursor = paginatedResult.nextCursor;
-                    }
-                    else if (paginatedResult.links?.next) {
-                        // Extract cursor from fully qualified URL (JSON:API spec format)
-                        nextCursor = extractCursor({ next: paginatedResult.links.next });
-                    }
-                    return {
-                        data: Array.isArray(paginatedResult.data)
-                            ? paginatedResult.data
-                            : [paginatedResult.data],
-                        nextCursor,
-                    };
-                }
-                // If result is an array, wrap in {data: result}
-                if (Array.isArray(result)) {
-                    return { data: result };
-                }
-                // If result is non-array, wrap in {data: [result]}
-                return { data: [result] };
-            }
-            catch (error) {
-                // Catch and normalize any errors, then rethrow
-                throw normalizeError(error);
-            }
-        },
-    };
-    return namedFunctions[functionName];
-}
-export function createPaginatedFunction(coreFn, schema, telemetry, explicitFunctionName) {
-    const pageFunction = createPageFunction(coreFn);
-    const functionName = explicitFunctionName || coreFn.name;
-    const validator = schema ? createValidator(schema) : null;
-    // Create the main paginated function
-    const namedFunctions = {
-        [functionName]: function (options) {
-            const startTime = Date.now();
-            // Convert undefined options to empty object
-            const normalizedOptions = (options ?? {});
-            const isNested = normalizedOptions?._telemetry?.isNested === true;
-            // Validate options if schema provided (validated fields take precedence)
-            const validatedOptions = {
-                ...normalizedOptions,
-                ...(validator ? validator(normalizedOptions) : normalizedOptions),
-            };
-            // Set default pageSize if not provided
-            const pageSize = validatedOptions.pageSize || 100;
-            const optimizedOptions = {
-                ...validatedOptions,
-                pageSize,
-            };
-            const iterator = paginate(pageFunction, optimizedOptions);
-            // Get a promise for the first iteration
-            const firstPagePromise = iterator.next().then((result) => {
-                if (result.done) {
-                    throw new Error("Paginate should always iterate at least once");
-                }
-                return result.value;
-            });
-            // Emit telemetry after first page completes
-            if (!isNested && telemetry?.onMethodCalled) {
-                firstPagePromise
-                    .then(() => {
-                    const argumentCount = Object.keys(normalizedOptions).filter((k) => k !== "_telemetry").length;
-                    telemetry.onMethodCalled({
-                        methodName: functionName,
-                        durationMs: Date.now() - startTime,
-                        success: true,
-                        argumentCount,
-                        isPaginated: true,
-                    });
-                })
-                    .catch((error) => {
-                    const argumentCount = Object.keys(normalizedOptions).filter((k) => k !== "_telemetry").length;
-                    telemetry.onMethodCalled({
-                        methodName: functionName,
-                        durationMs: Date.now() - startTime,
-                        success: false,
-                        error: error instanceof Error ? error : new Error(String(error)),
-                        argumentCount,
-                        isPaginated: true,
-                    });
-                });
-            }
-            // Add Symbol.asyncIterator to make the promise iterable
-            return Object.assign(firstPagePromise, {
-                [Symbol.asyncIterator]: async function* () {
-                    // Yield the first page (await the promise)
-                    yield await firstPagePromise;
-                    // Yield the rest of the pages
-                    for await (const page of iterator) {
-                        yield page;
-                    }
-                },
-                items: function () {
-                    return {
-                        [Symbol.asyncIterator]: async function* () {
-                            // Yield the first page items
-                            const firstPage = await firstPagePromise;
-                            for (const item of firstPage.data) {
-                                yield item;
-                            }
-                            // Yield items from the rest of the pages
-                            for await (const page of iterator) {
-                                for (const item of page.data) {
-                                    yield item;
-                                }
-                            }
-                        },
-                    };
-                },
-            });
-        },
-    };
-    return namedFunctions[functionName];
-}

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,110 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createFunction, createPaginatedFunction } from "./function-utils";
-import { ZapierValidationError, ZapierUnknownError } from "../types/errors";
-import { ALL_ITEMS, listTestItems } from "./pagination-utils.test";
-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));
-    });
-});

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

@@ -1,13 +0,0 @@
-/**
- * Utility functions for working with IDs
- */
-/**
- * Coerces a string or number ID to a number for API calls that require numeric IDs.
- *
- * @param fieldName - The name of the field (for error messages)
- * @param value - The ID value to coerce
- * @returns The numeric ID
- * @throws {ZapierValidationError} If the value cannot be converted to a valid number
- */
-export declare function coerceToNumericId(fieldName: string, value: string | number): number;
-//# sourceMappingURL=id-utils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"id-utils.d.ts","sourceRoot":"","sources":["../../src/utils/id-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GAAG,MAAM,GACrB,MAAM,CAcR"}

package/dist/utils/id-utils.js

@@ -1,22 +0,0 @@
-/**
- * Utility functions for working with IDs
- */
-import { ZapierValidationError } from "../types/errors";
-/**
- * Coerces a string or number ID to a number for API calls that require numeric IDs.
- *
- * @param fieldName - The name of the field (for error messages)
- * @param value - The ID value to coerce
- * @returns The numeric ID
- * @throws {ZapierValidationError} If the value cannot be converted to a valid number
- */
-export function coerceToNumericId(fieldName, value) {
-    if (value === "") {
-        throw new ZapierValidationError(`The ${fieldName} cannot be empty`);
-    }
-    const numericValue = typeof value === "number" ? value : Number(value);
-    if (!Number.isFinite(numericValue)) {
-        throw new ZapierValidationError(`The ${fieldName} "${value}" could not be converted to a number`);
-    }
-    return numericValue;
-}

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.d.ts

@@ -1,37 +0,0 @@
-type TPageOptions<TOptions> = TOptions extends undefined ? {
-    cursor?: string;
-    maxItems?: number;
-    pageSize?: number;
-} : TOptions & {
-    cursor?: string;
-    maxItems?: number;
-    pageSize?: number;
-};
-export declare function createPrefixedCursor(prefix: string, cursor: string | undefined): string;
-export declare function splitPrefixedCursor(cursor: string | undefined, prefixes?: string[]): [string | undefined, string | undefined];
-/**
- * Utility for paginating through API endpoints that return cursor-based pages
- *
- * @param pageFunction - Function that fetches a single page with {data, nextCursor} structure
- * @param pageOptions - Options to pass to the page function (cursor will be managed automatically)
- * @returns Async iterator that yields pages
- */
-export declare function paginateMaxItems<TOptions, TPage extends {
-    data: any[];
-    nextCursor?: string;
-}>(pageFunction: (options: TOptions & {
-    cursor?: string;
-    maxItems?: number;
-    pageSize?: number;
-}) => Promise<TPage>, pageOptions?: TPageOptions<TOptions>): AsyncIterableIterator<TPage>;
-export declare function paginateBuffered<TOptions, TPage extends {
-    data: any[];
-    nextCursor?: string;
-}>(pageFunction: (options: TOptions & {
-    cursor?: string;
-    maxItems?: number;
-    pageSize?: number;
-}) => Promise<TPage>, pageOptions?: TPageOptions<TOptions>): AsyncIterableIterator<TPage>;
-export declare const paginate: typeof paginateBuffered;
-export {};
-//# sourceMappingURL=pagination-utils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pagination-utils.d.ts","sourceRoot":"","sources":["../../src/utils/pagination-utils.ts"],"names":[],"mappings":"AAEA,KAAK,YAAY,CAAC,QAAQ,IAAI,QAAQ,SAAS,SAAS,GACpD;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GACzD,QAAQ,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAoCzE,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,CAKR;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,QAAQ,CAAC,EAAE,MAAM,EAAE,GAClB,CAAC,MAAM,GAAG,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC,CAkB1C;AAED;;;;;;GAMG;AACH,wBAAuB,gBAAgB,CACrC,QAAQ,EACR,KAAK,SAAS;IAAE,IAAI,EAAE,GAAG,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,EAElD,YAAY,EAAE,CACZ,OAAO,EAAE,QAAQ,GAAG;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,KACE,OAAO,CAAC,KAAK,CAAC,EACnB,WAAW,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,GACnC,qBAAqB,CAAC,KAAK,CAAC,CAoC9B;AAED,wBAAuB,gBAAgB,CACrC,QAAQ,EACR,KAAK,SAAS;IAAE,IAAI,EAAE,GAAG,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,EAElD,YAAY,EAAE,CACZ,OAAO,EAAE,QAAQ,GAAG;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,KACE,OAAO,CAAC,KAAK,CAAC,EACnB,WAAW,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,GACnC,qBAAqB,CAAC,KAAK,CAAC,CAiG9B;AAED,eAAO,MAAM,QAAQ,yBAAmB,CAAC"}