@zapier/zapier-sdk 0.65.0 → 0.67.0

package/dist/utils/function-utils.js

@@ -1,245 +0,0 @@
-/**
- * Generic utility functions for creating paginated SDK functions
- */
-import { ZapierError, ZapierUnknownError, ZapierAuthenticationError, } from "../types/errors";
-import { paginate } from "./pagination-utils";
-import { createValidator, validateOptions } from "./validation";
-import { isTelemetryNested, runWithTelemetryContext, } from "./telemetry-context";
-/**
- * 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.
- * Recognizes errors by name (e.g., from cli-login package which can't
- * import SDK errors directly) and converts them to proper SDK errors.
- */
-function normalizeError(error) {
-    if (error instanceof ZapierError) {
-        return error;
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    const cause = error instanceof Error ? error : undefined;
-    // Check for known error names from packages that can't import SDK errors
-    if (error instanceof Error) {
-        if (error.name === "ZapierAuthenticationError") {
-            return new ZapierAuthenticationError(message, { cause });
-        }
-    }
-    return new ZapierUnknownError(message, { cause });
-}
-/**
- * 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) {
-            return runWithTelemetryContext(async () => {
-                const startTime = Date.now();
-                const normalizedOptions = (options ?? {});
-                const isNested = isTelemetryNested();
-                try {
-                    if (schema) {
-                        const validatedOptions = validateOptions(schema, normalizedOptions);
-                        const result = await coreFn({
-                            ...normalizedOptions,
-                            ...validatedOptions,
-                        });
-                        if (!isNested && telemetry?.onMethodCalled) {
-                            const argumentCount = Object.keys(normalizedOptions).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).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).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, defaultPageSize) {
-    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) {
-            return runWithTelemetryContext(() => {
-                const startTime = Date.now();
-                // Convert undefined options to empty object
-                const normalizedOptions = (options ?? {});
-                const isNested = isTelemetryNested();
-                // Validate options if schema provided (validated fields take precedence)
-                const validatedOptions = {
-                    ...normalizedOptions,
-                    ...(validator ? validator(normalizedOptions) : normalizedOptions),
-                };
-                const pageSize = validatedOptions.pageSize ?? defaultPageSize;
-                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).length;
-                        telemetry.onMethodCalled({
-                            methodName: functionName,
-                            durationMs: Date.now() - startTime,
-                            success: true,
-                            argumentCount,
-                            isPaginated: true,
-                        });
-                    })
-                        .catch((error) => {
-                        const argumentCount = Object.keys(normalizedOptions).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/pagination-utils.d.ts

@@ -1,73 +0,0 @@
-type TPageOptions<TOptions> = TOptions extends undefined ? {
-    cursor?: string;
-    maxItems?: number;
-    pageSize?: number;
-} : TOptions & {
-    cursor?: string;
-    maxItems?: number;
-    pageSize?: number;
-};
-export declare function decodeIncomingCursor(incoming?: string): {
-    offset: number;
-    cursor: string | undefined;
-};
-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.
- * Accepts and yields SDK-encoded cursor envelopes. Any incoming cursor is decoded
- * before being passed to the page function; all outgoing cursors are encoded.
- *
- * @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 with encoded cursors
- */
-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;
-interface PaginatedResult<TItem> {
-    data: TItem[];
-    nextCursor?: string;
-}
-type PaginatedSource<TItem> = () => PromiseLike<PaginatedResult<TItem>> & AsyncIterable<PaginatedResult<TItem>>;
-/**
- * Concatenate multiple paginated SDK results into a single paginated stream.
- * Each source is a function returning a dual Promise+AsyncIterable (as SDK
- * paginated methods return). Sources are drained in order.
- *
- * The optional `dedupe` key extractor filters items from source N against
- * all items seen in sources 0 through N-1.
- *
- * Uses paginateBuffered internally to normalize page sizes across source
- * boundaries — e.g. if the first source only has 2 items, they'll be
- * buffered with items from the next source into a full page.
- *
- * Returns the same dual Promise+AsyncIterable shape that resolvers expect.
- */
-export declare function concatPaginated<TItem>({ sources, dedupe, pageSize, }: {
-    sources: PaginatedSource<TItem>[];
-    dedupe?: (item: TItem) => string;
-    pageSize?: number;
-}): PromiseLike<PaginatedResult<TItem>> & AsyncIterable<PaginatedResult<TItem>>;
-/**
- * Strip the PromiseLike from an async iterable, returning a plain
- * AsyncIterable. This prevents async functions from unwrapping the
- * iterable (since async only unwraps PromiseLike, not AsyncIterable).
- */
-export declare function toIterable<T>(source: AsyncIterable<T>): AsyncIterable<T>;
-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":"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"}

package/dist/utils/pagination-utils.js

@@ -1,308 +0,0 @@
-const CURSOR_VERSION = 1;
-const CURSOR_SOURCE = {
-    API: "api",
-    SDK: "sdk",
-};
-function encodeBase64(str) {
-    return btoa(Array.from(new TextEncoder().encode(str), (b) => String.fromCharCode(b)).join(""));
-}
-function decodeBase64(str) {
-    return new TextDecoder().decode(Uint8Array.from(atob(str), (c) => c.charCodeAt(0)));
-}
-function encodeApiCursor(cursor) {
-    const envelope = {
-        v: CURSOR_VERSION,
-        source: CURSOR_SOURCE.API,
-        cursor,
-    };
-    return encodeBase64(JSON.stringify(envelope));
-}
-function encodeSdkCursor(offset, cursor) {
-    const envelope = {
-        v: CURSOR_VERSION,
-        source: CURSOR_SOURCE.SDK,
-        cursor,
-        offset,
-    };
-    return encodeBase64(JSON.stringify(envelope));
-}
-export function decodeIncomingCursor(incoming) {
-    if (!incoming) {
-        return { offset: 0, cursor: undefined };
-    }
-    try {
-        const decoded = decodeBase64(incoming);
-        const envelope = JSON.parse(decoded);
-        if (envelope.v !== CURSOR_VERSION) {
-            return { offset: 0, cursor: incoming };
-        }
-        if (envelope.source === CURSOR_SOURCE.SDK) {
-            return { offset: envelope.offset ?? 0, cursor: envelope.cursor };
-        }
-        if (envelope.source === CURSOR_SOURCE.API) {
-            return { offset: 0, cursor: envelope.cursor };
-        }
-        return { offset: 0, cursor: incoming };
-    }
-    catch {
-        return { offset: 0, cursor: incoming };
-    }
-}
-export function createPrefixedCursor(prefix, cursor) {
-    if (!cursor) {
-        return `${prefix}::`;
-    }
-    return `${prefix}::${cursor}`;
-}
-export function splitPrefixedCursor(cursor, prefixes) {
-    if (!cursor) {
-        return [undefined, undefined];
-    }
-    const [prefix, ...rest] = cursor.split("::");
-    if (prefixes && !prefixes.includes(prefix)) {
-        return [undefined, cursor];
-    }
-    cursor = rest.join("::");
-    if (!cursor) {
-        return [prefix, undefined];
-    }
-    return [prefix, cursor];
-}
-/**
- * Internal primitive: paginates through a page function using raw (unencoded) cursors.
- * Encoding and decoding of cursors is the responsibility of the public wrappers.
- */
-async function* paginateMaxItemsWithUnencodedCursor(pageFunction, pageOptions) {
-    let cursor = pageOptions?.cursor;
-    let totalItemsYielded = 0;
-    const maxItems = pageOptions?.maxItems;
-    const pageSize = pageOptions?.pageSize;
-    do {
-        const options = {
-            ...(pageOptions || {}),
-            cursor,
-            pageSize: maxItems !== undefined && pageSize !== undefined
-                ? Math.min(pageSize, maxItems)
-                : pageSize,
-        };
-        const page = await pageFunction(options);
-        if (maxItems !== undefined) {
-            const remainingItems = maxItems - totalItemsYielded;
-            if (page.data.length >= remainingItems) {
-                yield {
-                    ...page,
-                    data: page.data.slice(0, remainingItems),
-                    nextCursor: undefined,
-                };
-                break;
-            }
-        }
-        yield page;
-        totalItemsYielded += page.data.length;
-        cursor = page.nextCursor;
-    } while (cursor);
-}
-/**
- * Utility for paginating through API endpoints that return cursor-based pages.
- * Accepts and yields SDK-encoded cursor envelopes. Any incoming cursor is decoded
- * before being passed to the page function; all outgoing cursors are encoded.
- *
- * @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 with encoded cursors
- */
-export async function* paginateMaxItems(pageFunction, pageOptions) {
-    const { cursor } = decodeIncomingCursor(pageOptions?.cursor);
-    const options = {
-        ...(pageOptions || {}),
-        cursor,
-    };
-    for await (const page of paginateMaxItemsWithUnencodedCursor(pageFunction, options)) {
-        yield {
-            ...page,
-            nextCursor: page.nextCursor
-                ? encodeApiCursor(page.nextCursor)
-                : undefined,
-        };
-    }
-}
-export async function* paginateBuffered(pageFunction, pageOptions) {
-    const pageSize = pageOptions?.pageSize;
-    const { offset: cursorOffset, cursor: initialCursor } = decodeIncomingCursor(pageOptions?.cursor);
-    const requestedMaxItems = pageOptions?.maxItems;
-    const options = {
-        ...(pageOptions || {}),
-        cursor: initialCursor,
-        // SDK cursors can carry an offset into a raw backend page. Since maxItems
-        // is expected to be relative to the resumed position, we add that offset
-        // so raw pagination still yields enough items after offset slicing.
-        maxItems: requestedMaxItems !== undefined && cursorOffset > 0
-            ? requestedMaxItems + cursorOffset
-            : requestedMaxItems,
-    };
-    if (!pageSize) {
-        for await (const page of paginateMaxItemsWithUnencodedCursor(pageFunction, options)) {
-            yield {
-                ...page,
-                nextCursor: page.nextCursor
-                    ? encodeApiCursor(page.nextCursor)
-                    : undefined,
-            };
-        }
-        return;
-    }
-    let bufferedPages = [];
-    let isFirstPage = true;
-    let rawCursor;
-    for await (let page of paginateMaxItemsWithUnencodedCursor(pageFunction, options)) {
-        const nextRawCursor = page.nextCursor;
-        if (isFirstPage) {
-            isFirstPage = false;
-            if (cursorOffset) {
-                page = {
-                    ...page,
-                    data: page.data.slice(cursorOffset),
-                };
-            }
-        }
-        const bufferedLength = bufferedPages.reduce((acc, p) => acc + p.data.length, 0);
-        // If we don't have enough to fill a page, buffer this page.
-        if (bufferedLength + page.data.length < pageSize) {
-            bufferedPages.push(page);
-            rawCursor = nextRawCursor;
-            continue;
-        }
-        // Let's yield a page from our buffered pages.
-        const bufferedItems = bufferedPages.map((p) => p.data).flat();
-        const allItems = [...bufferedItems, ...page.data];
-        const pageItems = allItems.slice(0, pageSize);
-        const remainingItems = allItems.slice(pageItems.length);
-        // No extra items to buffer, so we can just yield a normal page with a cursor to the next one.
-        if (remainingItems.length === 0) {
-            yield {
-                ...page,
-                data: pageItems,
-                nextCursor: nextRawCursor ? encodeApiCursor(nextRawCursor) : undefined,
-            };
-            bufferedPages = [];
-            rawCursor = nextRawCursor;
-            continue;
-        }
-        // Yield our items with a cursor to offset into this page.
-        yield {
-            ...page,
-            data: pageItems,
-            nextCursor: encodeSdkCursor(page.data.length - remainingItems.length, rawCursor),
-        };
-        while (remainingItems.length > pageSize) {
-            const chunkItems = remainingItems.splice(0, pageSize);
-            yield {
-                ...page,
-                data: chunkItems,
-                nextCursor: encodeSdkCursor(page.data.length - remainingItems.length, rawCursor),
-            };
-        }
-        bufferedPages = [
-            {
-                ...page,
-                data: remainingItems,
-            },
-        ];
-        rawCursor = nextRawCursor;
-    }
-    if (bufferedPages.length > 0) {
-        const lastBufferedPage = bufferedPages.slice(-1)[0];
-        const bufferedItems = bufferedPages.map((p) => p.data).flat();
-        yield {
-            ...lastBufferedPage,
-            data: bufferedItems,
-        };
-    }
-}
-export const paginate = paginateBuffered;
-/**
- * Concatenate multiple paginated SDK results into a single paginated stream.
- * Each source is a function returning a dual Promise+AsyncIterable (as SDK
- * paginated methods return). Sources are drained in order.
- *
- * The optional `dedupe` key extractor filters items from source N against
- * all items seen in sources 0 through N-1.
- *
- * Uses paginateBuffered internally to normalize page sizes across source
- * boundaries — e.g. if the first source only has 2 items, they'll be
- * buffered with items from the next source into a full page.
- *
- * Returns the same dual Promise+AsyncIterable shape that resolvers expect.
- */
-export function concatPaginated({ sources, dedupe, pageSize = 100, }) {
-    if (sources.length === 0) {
-        const empty = { data: [] };
-        return Object.assign(Promise.resolve(empty), {
-            [Symbol.asyncIterator]: async function* () {
-                yield empty;
-            },
-        });
-    }
-    let sourceIndex = 0;
-    let currentIterator = null;
-    const seen = new Set();
-    const pageFunction = async (_options) => {
-        while (sourceIndex < sources.length) {
-            if (!currentIterator) {
-                const result = sources[sourceIndex]();
-                currentIterator = result[Symbol.asyncIterator]();
-            }
-            const next = await currentIterator.next();
-            if (next.done) {
-                sourceIndex++;
-                currentIterator = null;
-                continue;
-            }
-            let items = next.value.data;
-            if (dedupe) {
-                if (sourceIndex > 0) {
-                    items = items.filter((item) => !seen.has(dedupe(item)));
-                }
-                for (const item of items) {
-                    seen.add(dedupe(item));
-                }
-            }
-            const hasMoreInSource = next.value.nextCursor != null;
-            const hasMoreSources = sourceIndex < sources.length - 1;
-            // Synthetic sentinel — not a real API cursor. It just signals to
-            // paginateBuffered that more data exists (from the current source or
-            // the next one). This works because concatPaginated manages its own
-            // iteration state internally. Currently only used by CLI resolvers;
-            // if this is ever used in user-facing SDK methods, we should replace
-            // it with a stateless composite cursor (e.g. sourceIndex + inner cursor).
-            return {
-                data: items,
-                nextCursor: hasMoreInSource || hasMoreSources ? "__has_more__" : undefined,
-            };
-        }
-        return { data: [] };
-    };
-    const iterator = paginateBuffered(pageFunction, { pageSize });
-    const firstPagePromise = iterator.next().then((result) => {
-        if (result.done) {
-            return { data: [] };
-        }
-        return result.value;
-    });
-    return Object.assign(firstPagePromise, {
-        [Symbol.asyncIterator]: async function* () {
-            yield await firstPagePromise;
-            for await (const page of { [Symbol.asyncIterator]: () => iterator }) {
-                yield page;
-            }
-        },
-    });
-}
-/**
- * Strip the PromiseLike from an async iterable, returning a plain
- * AsyncIterable. This prevents async functions from unwrapping the
- * iterable (since async only unwraps PromiseLike, not AsyncIterable).
- */
-export function toIterable(source) {
-    return { [Symbol.asyncIterator]: () => source[Symbol.asyncIterator]() };
-}