@zapier/zapier-sdk 0.4.1 → 0.5.0

package/dist/plugins/listApps/index.test.js

@@ -0,0 +1,313 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError } from "../../types/errors";
+import { listAppsPlugin } from "./index";
+import { createSdk } from "../../sdk";
+import { apiPlugin } from "../api/index";
+const mockAppsResponse = {
+    results: [
+        {
+            id: "SlackCLIAPI@1.0.0",
+            slug: "slack",
+            name: "Slack",
+            description: "Team communication",
+            primary_color: "#4A154B",
+            categories: ["communication"],
+        },
+        {
+            id: "GoogleSheetsCLIAPI@1.0.0",
+            slug: "google-sheets",
+            name: "Google Sheets",
+            description: "Online spreadsheets",
+            primary_color: "#34A853",
+            categories: ["productivity"],
+        },
+    ],
+    meta: {
+        next_cursor: null,
+    },
+};
+function createTestSdk() {
+    return createSdk()
+        .addPlugin(apiPlugin, { fetch: global.fetch })
+        .addPlugin(listAppsPlugin);
+}
+describe("listApps plugin", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("schema validation", () => {
+        it("should pass validation with empty options", async () => {
+            const mockServicesResponse = {
+                results: [
+                    {
+                        id: "slack_service_id",
+                        slug: "slack",
+                        name: "Slack",
+                        description: "Team communication",
+                        current_implementation_id: "SlackCLIAPI@1.0.0",
+                    },
+                    {
+                        id: "sheets_service_id",
+                        slug: "google-sheets",
+                        name: "Google Sheets",
+                        description: "Online spreadsheets",
+                        current_implementation_id: "GoogleSheetsCLIAPI@1.0.0",
+                    },
+                ],
+                next: null,
+            };
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            // Mock the API client in context
+            context.api.get = vi
+                .fn()
+                .mockResolvedValue(mockServicesResponse);
+            const result = await sdk.listApps({});
+            expect(result.data).toHaveLength(2);
+        });
+        it("should handle undefined options by converting to empty object", async () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            // Mock the API client in context
+            context.api.get = vi.fn().mockResolvedValueOnce({
+                results: [
+                    {
+                        id: "SlackCLIAPI@1.0.0",
+                        name: "Slack",
+                        description: "Team communication",
+                        primary_color: "#4A154B",
+                        categories: ["communication"],
+                    },
+                ],
+                next: null,
+            });
+            const result = await sdk.listApps(undefined);
+            expect(result.data).toHaveLength(1);
+            expect(result.data[0]).toMatchObject({
+                key: "SlackCLIAPI",
+                title: "Slack",
+            });
+            expect(context.api.get).toHaveBeenCalledWith("/api/v4/implementations-meta/lookup/", {
+                searchParams: { latest_only: "true", limit: "100" },
+            });
+        });
+        it("should throw validation error for invalid pageSize", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listApps({
+                    pageSize: 0, // Should be >= 1
+                });
+            }).toThrow(ZapierValidationError);
+            expect(() => {
+                sdk.listApps({
+                    pageSize: -5, // Should be >= 1
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid maxItems", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listApps({
+                    maxItems: 0, // Should be >= 1
+                });
+            }).toThrow(ZapierValidationError);
+            expect(() => {
+                sdk.listApps({
+                    maxItems: -10, // Should be >= 1
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid appKeys type", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listApps({
+                    appKeys: 123,
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should pass validation with all valid fields", async () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            // Mock the API client in context
+            context.api.get = vi.fn().mockResolvedValueOnce({
+                results: [
+                    {
+                        id: "SlackCLIAPI@1.0.0",
+                        name: "Slack",
+                        description: "Team communication",
+                        primary_color: "#4A154B",
+                        categories: ["communication"],
+                    },
+                    {
+                        id: "GitHubCLIAPI@1.0.0",
+                        name: "GitHub",
+                        description: "Code repository hosting",
+                        primary_color: "#24292e",
+                        categories: ["developer-tools"],
+                    },
+                ],
+                next: null,
+            });
+            const result = await sdk.listApps({
+                appKeys: ["SlackCLIAPI", "GitHubCLIAPI"],
+                pageSize: 10,
+                maxItems: 50,
+            });
+            expect(result.data).toHaveLength(2);
+            expect(result.data[0].key).toBe("SlackCLIAPI");
+            expect(result.data[1].key).toBe("GitHubCLIAPI");
+        });
+    });
+    describe("data mapping", () => {
+        it("should return essential app properties", async () => {
+            const mockServicesResponse = {
+                results: [
+                    {
+                        id: "slack_service_id",
+                        slug: "slack",
+                        name: "Slack",
+                        description: "Team communication",
+                        current_implementation_id: "SlackCLIAPI@1.0.0",
+                    },
+                ],
+                next: null,
+            };
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            // Mock the API client in context
+            context.api.get = vi
+                .fn()
+                .mockResolvedValue(mockServicesResponse);
+            const result = await sdk.listApps({});
+            expect(result.data[0]).toHaveProperty("title");
+            expect(result.data[0]).toHaveProperty("key");
+            expect(result.data[0]).toHaveProperty("current_implementation_id");
+            // Version is optional
+            expect(result.data[0]).toHaveProperty("version");
+        });
+    });
+    describe("pagination", () => {
+        it("should handle pagination with maxItems", async () => {
+            const mockServicesResponse = {
+                results: [
+                    {
+                        id: "slack_service_id",
+                        slug: "slack",
+                        name: "Slack",
+                        description: "Team communication",
+                        current_implementation_id: "SlackCLIAPI@1.0.0",
+                    },
+                    {
+                        id: "sheets_service_id",
+                        slug: "google-sheets",
+                        name: "Google Sheets",
+                        description: "Online spreadsheets",
+                        current_implementation_id: "GoogleSheetsCLIAPI@1.0.0",
+                    },
+                ],
+                next: null,
+            };
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            const mockGet = vi.fn().mockResolvedValue(mockServicesResponse);
+            context.api.get = mockGet;
+            const result = await sdk.listApps({ maxItems: 5 });
+            // Should return all items since maxItems (5) is greater than available items (2)
+            expect(result.data).toHaveLength(2);
+            expect(mockGet).toHaveBeenCalledTimes(1);
+        });
+        it("should support async iteration over pages", async () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            const mockGet = vi
+                .fn()
+                .mockResolvedValueOnce({
+                results: [
+                    {
+                        id: "SlackCLIAPI@1.0.0",
+                        slug: "slack",
+                        name: "Slack",
+                        description: "Team communication",
+                    },
+                ],
+                next: "https://zapier.com/api/v4/services/?offset=cursor-page-2",
+            })
+                .mockResolvedValueOnce({
+                results: [
+                    {
+                        id: "GoogleSheetsCLIAPI@1.0.0",
+                        slug: "google-sheets",
+                        name: "Google Sheets",
+                        description: "Online spreadsheets",
+                    },
+                ],
+                next: null,
+            });
+            context.api.get = mockGet;
+            const pages = [];
+            for await (const page of sdk.listApps({ pageSize: 1 })) {
+                pages.push(page);
+                if (pages.length >= 2)
+                    break;
+            }
+            expect(pages).toHaveLength(2);
+            expect(pages[0].data).toHaveLength(1);
+            expect(pages[1].data).toHaveLength(1);
+            expect(pages[0].data[0].key).toBe("SlackCLIAPI");
+            expect(pages[1].data[0].key).toBe("GoogleSheetsCLIAPI");
+        });
+        it("should support async iteration over individual items", async () => {
+            const mockServicesResponse = {
+                results: [
+                    {
+                        id: "SlackCLIAPI@1.0.0",
+                        slug: "slack",
+                        name: "Slack",
+                        description: "Team communication",
+                    },
+                    {
+                        id: "GoogleSheetsCLIAPI@1.0.0",
+                        slug: "google-sheets",
+                        name: "Google Sheets",
+                        description: "Online spreadsheets",
+                    },
+                ],
+                next: null,
+            };
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            context.api.get = vi
+                .fn()
+                .mockResolvedValue(mockServicesResponse);
+            const items = [];
+            for await (const item of sdk.listApps({ maxItems: 2 }).items()) {
+                items.push(item);
+            }
+            expect(items).toHaveLength(2);
+            expect(items[0].key).toBe("SlackCLIAPI");
+            expect(items[1].key).toBe("GoogleSheetsCLIAPI");
+        });
+    });
+    describe("API integration", () => {
+        it("should pass appKeys filter to API", async () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            const mockGet = vi.fn().mockResolvedValue(mockAppsResponse);
+            context.api.get = mockGet;
+            await sdk.listApps({ appKeys: ["SlackCLIAPI", "GitHubCLIAPI"] });
+            expect(mockGet).toHaveBeenCalledWith(expect.stringContaining("implementations-meta"), expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    selected_apis: "SlackCLIAPI,GitHubCLIAPI",
+                }),
+            }));
+        });
+    });
+    describe("plugin integration", () => {
+        it("should provide metadata in context", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.listApps).toBeDefined();
+            expect(context.meta.listApps.inputSchema).toBeDefined();
+        });
+    });
+});

package/dist/plugins/listApps/schemas.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import type { AppItem } from "../../types/domain";
+import type { PaginatedSdkFunction } from "../../types/functions";
+import { ZapierApiError, ZapierValidationError } from "../../types/errors";
+export type ListAppsError = ZapierApiError | ZapierValidationError;
+export interface ListAppsPage {
+    data: AppItem[];
+    nextCursor?: string;
+}
+export declare const ListAppsSchema: z.ZodObject<{
+    appKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    search: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
+    maxItems?: number | undefined;
+    pageSize?: number | undefined;
+    appKeys?: string[] | undefined;
+}, {
+    search?: string | undefined;
+    maxItems?: number | undefined;
+    pageSize?: number | undefined;
+    appKeys?: string[] | undefined;
+}>;
+export type ListAppsOptions = z.infer<typeof ListAppsSchema>;
+export interface ListAppsSdkFunction {
+    listApps: PaginatedSdkFunction<ListAppsOptions | undefined, AppItem>;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/listApps/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/listApps/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAK3E,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG,qBAAqB,CAAC;AAGnE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAuB1B,CAAC;AAGF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAG7D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,oBAAoB,CAAC,eAAe,GAAG,SAAS,EAAE,OAAO,CAAC,CAAC;CACtE"}

package/dist/plugins/listApps/schemas.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { AppItemSchema } from "../../schemas/App";
+import { withOutputSchema } from "../../utils/schema-utils";
+// Pure Zod schema - no pagination metadata exposed
+export const ListAppsSchema = withOutputSchema(z
+    .object({
+    appKeys: z
+        .array(z.string())
+        .optional()
+        .describe("Filter apps by app keys (e.g., 'SlackCLIAPI' or slug like 'github')"),
+    search: z.string().optional().describe("Search for apps by name"),
+    pageSize: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Number of apps per page"),
+    maxItems: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Maximum total items to return across all pages"),
+})
+    .describe("List all available apps with optional filtering"), AppItemSchema);

package/dist/plugins/listAuthentications/index.d.ts

@@ -0,0 +1,28 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { ApiClient } from "../../api";
+import type { AuthenticationItem } from "../../types/domain";
+import { ListAuthenticationsSchema, type ListAuthenticationsOptions } from "./schemas";
+import type { GetAppPluginProvides } from "../getApp";
+export interface ListAuthenticationsPluginProvides {
+    listAuthentications: (options?: ListAuthenticationsOptions) => Promise<{
+        data: AuthenticationItem[];
+    }> & AsyncIterable<{
+        data: AuthenticationItem[];
+        nextCursor?: string;
+    }> & {
+        items(): AsyncIterable<AuthenticationItem>;
+    };
+    context: {
+        meta: {
+            listAuthentications: {
+                inputSchema: typeof ListAuthenticationsSchema;
+            };
+        };
+    };
+}
+export declare const listAuthenticationsPlugin: Plugin<GetSdkType<GetAppPluginProvides>, // requires getApp in SDK
+{
+    api: ApiClient;
+}, // requires api in context
+ListAuthenticationsPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/listAuthentications/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/listAuthentications/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EACL,yBAAyB,EACzB,KAAK,0BAA0B,EAEhC,MAAM,WAAW,CAAC;AAOnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAEtD,MAAM,WAAW,iCAAiC;IAChD,mBAAmB,EAAE,CAAC,OAAO,CAAC,EAAE,0BAA0B,KAAK,OAAO,CAAC;QACrE,IAAI,EAAE,kBAAkB,EAAE,CAAC;KAC5B,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QACnE,KAAK,IAAI,aAAa,CAAC,kBAAkB,CAAC,CAAC;KAC5C,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,mBAAmB,EAAE;gBACnB,WAAW,EAAE,OAAO,yBAAyB,CAAC;aAC/C,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAC5C,UAAU,CAAC,oBAAoB,CAAC,EAAE,yBAAyB;AAC3D;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAAE,0BAA0B;AAC9C,iCAAiC,CAmGlC,CAAC"}

package/dist/plugins/listAuthentications/index.js

@@ -0,0 +1,77 @@
+import { ListAuthenticationsSchema, } from "./schemas";
+import { normalizeAuthenticationItem } from "../../utils/domain-utils";
+import { ZapierAuthenticationError } from "../../types/errors";
+import { createPaginatedFunction, extractCursor, } from "../../utils/function-utils";
+export const listAuthenticationsPlugin = ({ sdk, context }) => {
+    const listAuthentications = createPaginatedFunction(async function listAuthenticationsPage(options) {
+        const { api } = context;
+        // Build search parameters
+        const searchParams = {};
+        // Handle appKey filtering by getting the selected_api first
+        if (options.appKey) {
+            const app = await sdk.getApp({
+                appKey: options.appKey,
+            });
+            const selectedApi = app.data.current_implementation_id;
+            if (selectedApi) {
+                // Use versionless_selected_api to find auths across all app versions
+                // Extract the base name without the version (e.g., "SlackCLIAPI" from "SlackCLIAPI@1.21.1")
+                const versionlessApi = selectedApi.split("@")[0];
+                searchParams.versionless_selected_api = versionlessApi;
+            }
+        }
+        // Add other query parameters if provided
+        // Use title as search if no explicit search provided
+        if (options.search) {
+            searchParams.search = options.search;
+        }
+        else if (options.title) {
+            searchParams.search = options.title;
+        }
+        if (options.account_id) {
+            searchParams.account_id = options.account_id;
+        }
+        if (options.owner) {
+            searchParams.owner = options.owner;
+        }
+        // pageSize is now guaranteed to be set by the higher-order function
+        searchParams.limit = options.pageSize.toString();
+        if (options.cursor) {
+            // Convert cursor back to offset for the API
+            searchParams.offset = options.cursor;
+        }
+        const data = await api.get("/api/v4/authentications/", {
+            searchParams,
+            customErrorHandler: ({ status }) => {
+                if (status === 401) {
+                    return new ZapierAuthenticationError(`Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${status})`, { statusCode: status });
+                }
+                if (status === 403) {
+                    return new ZapierAuthenticationError(`Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${status})`, { statusCode: status });
+                }
+                return undefined;
+            },
+            authRequired: true,
+        });
+        // Transform API response and filter by exact title match if specified
+        let auths = (data.results || []).map((auth) => normalizeAuthenticationItem(auth));
+        // Filter by exact title match if specified
+        if (options.title) {
+            auths = auths.filter((auth) => auth.title === options.title);
+        }
+        return {
+            data: auths,
+            nextCursor: extractCursor(data),
+        };
+    }, ListAuthenticationsSchema);
+    return {
+        listAuthentications,
+        context: {
+            meta: {
+                listAuthentications: {
+                    inputSchema: ListAuthenticationsSchema,
+                },
+            },
+        },
+    };
+};

package/dist/plugins/listAuthentications/index.test.d.ts

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

package/dist/plugins/listAuthentications/index.test.d.ts.map

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