@zapier/zapier-sdk 0.4.1 → 0.5.1

package/dist/utils/domain-utils.js

@@ -0,0 +1,218 @@
+/**
+ * Domain utility functions for working with app identifiers and data normalization
+ */
+/**
+ * Splits a versioned key to extract the base key and version
+ *
+ * @param versionedKey - Versioned key in format "KeyName@version" (e.g., "SlackCLIAPI@1.21.1")
+ * @returns Tuple of [baseKey, version] or [versionedKey, undefined] if no @ symbol
+ *
+ * @example
+ * splitVersionedKey("SlackCLIAPI@1.21.1") // ["SlackCLIAPI", "1.21.1"]
+ * splitVersionedKey("SomeAPI") // ["SomeAPI", undefined]
+ */
+export function splitVersionedKey(versionedKey) {
+    const parts = versionedKey.split("@");
+    if (parts.length >= 2) {
+        const baseKey = parts[0];
+        const version = parts.slice(1).join("@"); // Handle edge case of multiple @ symbols
+        return [baseKey, version];
+    }
+    return [versionedKey, undefined];
+}
+/**
+ * Converts an API App to an AppItem with normalized field names
+ *
+ * @param app - Raw App from API
+ * @returns Normalized AppItem
+ */
+export function normalizeAppItem(app) {
+    // Extract API name and version from current_implementation_id
+    const [apiName, appVersion] = app.current_implementation_id
+        ? splitVersionedKey(app.current_implementation_id)
+        : [app.current_implementation_id || "", undefined];
+    return {
+        title: app.name,
+        key: app.slug || apiName,
+        current_implementation_id: app.current_implementation_id || "",
+        version: appVersion, // Extract version separately
+    };
+}
+/**
+ * Converts an Implementation to an AppItem with normalized field names
+ *
+ * @param implementation - Raw Implementation from API
+ * @returns Normalized AppItem
+ */
+export function normalizeImplementationToAppItem(implementation) {
+    // Extract API name and version from selected_api
+    const [selectedApi, appVersion] = implementation.selected_api
+        ? splitVersionedKey(implementation.selected_api)
+        : [implementation.selected_api || "", undefined];
+    return {
+        title: implementation.name || selectedApi,
+        key: selectedApi,
+        current_implementation_id: implementation.selected_api || "",
+        version: appVersion, // Extract version separately
+    };
+}
+/**
+ * Converts a lightweight ImplementationMeta to a slimmed AppItem
+ *
+ * @param implementationMeta - Raw ImplementationMeta from API
+ * @returns Normalized AppItem with essential fields only
+ */
+export function normalizeImplementationMetaToAppItem(implementationMeta) {
+    // Extract API name and version from the implementation ID
+    const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
+    return {
+        title: implementationMeta.name,
+        key: selectedApi,
+        current_implementation_id: implementationMeta.id, // Keep the full versioned ID
+        version: appVersion, // Extract version separately
+        slug: implementationMeta.slug,
+    };
+}
+export function normalizeServiceToAppItem(service) {
+    const [selectedApi, appVersion] = service.current_implementation_id
+        ? splitVersionedKey(service.current_implementation_id)
+        : ["", undefined];
+    return {
+        title: service.name,
+        key: selectedApi,
+        current_implementation_id: service.current_implementation_id,
+        version: appVersion,
+        description: service.description,
+    };
+}
+/**
+ * Converts an API Authentication to an AuthenticationItem with normalized field names
+ *
+ * @param auth - Raw Authentication from API
+ * @param options - Additional fields to include
+ * @param options.app_key - selected_api from implementations endpoint
+ * @param options.version - Version extracted from selected_api
+ * @returns Normalized AuthenticationItem
+ */
+export function normalizeAuthenticationItem(auth, options = {}) {
+    // Extract app key and version from selected_api if not provided
+    let appKey = options.app_key;
+    let version = options.version;
+    if (auth.selected_api) {
+        const [extractedAppKey, extractedVersion] = splitVersionedKey(auth.selected_api);
+        // Use extracted app key if not provided in options
+        if (!appKey) {
+            appKey = extractedAppKey;
+        }
+        // Use extracted version if not provided in options
+        if (!version) {
+            version = extractedVersion;
+        }
+    }
+    const { selected_api: selectedApi, customuser_id: userId, ...restOfAuth } = auth;
+    return {
+        ...restOfAuth, // Pass through all other API response fields except selected_api
+        implementation_id: selectedApi, // Rename selected_api to implementation_id
+        title: auth.title || auth.label || undefined, // Coerce title from label if missing
+        is_expired: auth.is_stale, // Map is_stale to is_expired
+        expired_at: auth.marked_stale_at, // Map marked_stale_at to expired_at
+        app_key: appKey, // App key from implementations endpoint or parsed from selected_api
+        version, // Version from selected_api or provided
+        user_id: userId, // Map customuser_id to user_id
+    };
+}
+export function normalizeActionItem(action) {
+    const { name, type, selected_api: appKey, ...restOfAction } = action;
+    return {
+        ...restOfAction,
+        app_key: appKey || "",
+        action_type: type,
+        title: name, // Map name to title
+        type: "action",
+    };
+}
+/**
+ * Groups app keys by their type based on format patterns
+ *
+ * @param appKeys Array of app key strings to categorize
+ * @returns Object with arrays of keys grouped by type: selectedApi (CLI APIs), slug (everything else)
+ *
+ * @example
+ * groupVersionedAppKeysByType([
+ *   'FormatterCLIAPI@1.0.0',
+ *   'slack',
+ *   'AnotherAPI'
+ * ])
+ * // Returns: {
+ * //   selectedApi: ['FormatterCLIAPI@1.0.0', 'AnotherAPI'],
+ * //   slug: ['slack']
+ * // }
+ */
+export function groupVersionedAppKeysByType(appKeys) {
+    const result = {
+        selectedApi: [],
+        slug: [],
+    };
+    // Use Sets to track seen keys for deduplication
+    const seenSelectedApi = new Set();
+    const seenSlugs = new Set();
+    for (const key of appKeys) {
+        // Split by @ to get base name for classification (but preserve full key in results)
+        const [keyWithoutVersion, version] = splitVersionedKey(key);
+        // Check if it's a UUID (canonical ID) - not supported
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        if (uuidRegex.test(keyWithoutVersion)) {
+            throw new Error(`UUID app keys are not supported. Use app slug or implementation ID instead of: ${key}`);
+        }
+        // Check if it's a snake_case string
+        if (isSnakeCasedSlug(keyWithoutVersion)) {
+            const dashified = dashifySnakeCasedSlug(keyWithoutVersion);
+            const slugWithVersion = version ? `${dashified}@${version}` : dashified;
+            if (!seenSlugs.has(slugWithVersion)) {
+                seenSlugs.add(slugWithVersion);
+                result.slug.push(slugWithVersion); // Preserve full key including version
+            }
+            continue;
+        }
+        // Check if it's a slug (lowercase and dashes)
+        if (keyWithoutVersion.match(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)) {
+            seenSlugs.add(key);
+            result.slug.push(key);
+            continue;
+        }
+        // Everything else is a selected_api
+        if (!seenSelectedApi.has(key)) {
+            seenSelectedApi.add(key);
+            result.selectedApi.push(key); // Preserve full key including version
+        }
+    }
+    return result;
+}
+export function groupAppKeysByType(appKeys) {
+    const grouped = groupVersionedAppKeysByType(appKeys);
+    // Extract base keys and dedupe by using Set
+    return {
+        selectedApi: [
+            ...new Set(grouped.selectedApi.map((key) => key.split("@")[0])),
+        ],
+        slug: [...new Set(grouped.slug.map((key) => key.split("@")[0]))],
+    };
+}
+function isSnakeCasedSlug(slug) {
+    // Allow leading underscore for slugs starting with a number.
+    if (slug.match(/^_[0-9]/)) {
+        slug = slug.slice(1);
+    }
+    return !!slug.match(/^[a-z0-9]+(?:_[a-z0-9]+)*$/);
+}
+function dashifySnakeCasedSlug(slug) {
+    // Only dashify if it's a valid snake_cased slug.
+    if (!isSnakeCasedSlug(slug)) {
+        return slug;
+    }
+    // Allow one leading underscore for slugs starting with a number.
+    if (slug.startsWith("_")) {
+        slug = slug.slice(1);
+    }
+    return slug.replace(/_/g, "-");
+}

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

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

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

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

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

@@ -0,0 +1,192 @@
+import { describe, it, expect } from "vitest";
+import { groupVersionedAppKeysByType, groupAppKeysByType, } 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
+            ]);
+            expect(result).toEqual({
+                selectedApi: ["FormatterCLIAPI@1.0.0"],
+                slug: ["slack@2.1.0"],
+            });
+        });
+    });
+    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"],
+            });
+        });
+    });
+});

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

@@ -0,0 +1,45 @@
+/**
+ * Generic utility functions for creating paginated SDK functions
+ */
+import { z } from "zod";
+/**
+ * Helper function to extract cursor from pagination data
+ */
+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
+ * @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>): (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>): (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

@@ -0,0 +1 @@
+{"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;;GAEG;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;;;;;;GAMG;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,cAMQ,QAAQ,KAAG,OAAO,CAAC,OAAO,CAAC,CAqBxE;AAiDD;;;;;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,GACnC,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,CA8EF"}

package/dist/utils/function-utils.js

@@ -0,0 +1,158 @@
+/**
+ * Generic utility functions for creating paginated SDK functions
+ */
+import { ZapierError, ZapierUnknownError } from "../types/errors";
+import { paginate } from "./pagination-utils";
+import { createValidator, validateOptions } from "./validation";
+/**
+ * Helper function to extract cursor from pagination data
+ */
+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
+ * @returns A function that normalizes and rethrows errors
+ */
+export function createFunction(coreFn, schema) {
+    const functionName = coreFn.name;
+    // Create a named function using dynamic property access
+    const namedFunctions = {
+        [functionName]: async function (options) {
+            try {
+                // Convert undefined options to empty object
+                const normalizedOptions = (options ?? {});
+                if (schema) {
+                    const validatedOptions = validateOptions(schema, normalizedOptions);
+                    return await coreFn({
+                        ...normalizedOptions,
+                        ...validatedOptions,
+                    });
+                }
+                return await coreFn(normalizedOptions);
+            }
+            catch (error) {
+                // Catch and normalize any errors, then rethrow
+                throw normalizeError(error);
+            }
+        },
+    };
+    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 data = result.data;
+                    return {
+                        data: Array.isArray(data) ? data : [data],
+                        nextCursor: result.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) {
+    const pageFunction = createPageFunction(coreFn);
+    const functionName = coreFn.name;
+    const validator = schema ? createValidator(schema) : null;
+    // Create the main paginated function
+    const namedFunctions = {
+        [functionName]: function (options) {
+            // Convert undefined options to empty object
+            const normalizedOptions = (options ?? {});
+            // 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;
+            });
+            // 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

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

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

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