@zapier/zapier-sdk 0.8.3 → 0.10.0

package/src/plugins/listApps/index.test.ts

@@ -28,9 +28,26 @@ const mockAppsResponse = {
   },
 };
 
+const mockResolveAppKeys = vi
+  .fn()
+  .mockImplementation(async ({ appKeys }: { appKeys: string[] }) => {
+    // Mock implementation that returns resolved locators for the app keys
+    return appKeys.map((appKey) => ({
+      lookupAppKey: appKey,
+      implementationName: appKey, // For testing, use appKey as implementationName
+      slug: appKey.toLowerCase(),
+      version: undefined,
+    }));
+  });
+
 function createTestSdk() {
   return createSdk()
     .addPlugin(apiPlugin, { fetch: global.fetch })
+    .addPlugin(() => ({
+      context: {
+        resolveAppKeys: mockResolveAppKeys,
+      },
+    }))
     .addPlugin(listAppsPlugin as any);
 }
 
@@ -100,7 +117,11 @@ describe("listApps plugin", () => {
       expect((context.api as any).get).toHaveBeenCalledWith(
         "/api/v4/implementations-meta/lookup/",
         {
-          searchParams: { latest_only: "true", limit: "100" },
+          searchParams: {
+            latest_only: "true",
+            limit: "100",
+            selected_apis: "",
+          },
         },
       );
     });
@@ -207,7 +228,7 @@ describe("listApps plugin", () => {
 
       expect(result.data[0]).toHaveProperty("title");
       expect(result.data[0]).toHaveProperty("key");
-      expect(result.data[0]).toHaveProperty("current_implementation_id");
+      expect(result.data[0]).toHaveProperty("implementation_id");
       // Version is optional
       expect(result.data[0]).toHaveProperty("version");
     });
@@ -338,7 +359,7 @@ describe("listApps plugin", () => {
         expect.stringContaining("implementations-meta"),
         expect.objectContaining({
           searchParams: expect.objectContaining({
-            selected_apis: "SlackCLIAPI,GitHubCLIAPI",
+            selected_apis: "SlackCLIAPI@latest,GitHubCLIAPI@latest",
           }),
         }),
       );

package/src/plugins/listApps/index.ts

@@ -1,16 +1,20 @@
-import type { Plugin } from "../../types/plugin";
-import type { ApiClient } from "../../api/types";
+import type { GetContextType, Plugin } from "../../types/plugin";
 import { createPaginatedFunction } from "../../utils/function-utils";
 import { ListAppsSchema } from "./schemas";
 import type { ListAppsOptions, ListAppsPage } from "./schemas";
 import type { AppItem } from "../../types/domain";
+import { AppItemSchema } from "../../schemas/App";
+import type { ResolvedAppLocator } from "../../utils/domain-utils";
 import {
-  groupAppKeysByType,
   normalizeImplementationMetaToAppItem,
   splitVersionedKey,
+  toAppLocator,
+  toImplementationId,
 } from "../../utils/domain-utils";
 import { extractCursor } from "../../utils/function-utils";
 import type { ImplementationsMetaResponse } from "../../api/types";
+import type { ManifestPluginProvides } from "../manifest";
+import type { ApiPluginProvides } from "../api";
 // ListApps plugin provides interface - listApps goes directly to SDK root
 export interface ListAppsPluginProvides {
   listApps: (options?: ListAppsOptions) => Promise<{ data: AppItem[] }> &
@@ -26,10 +30,9 @@ export interface ListAppsPluginProvides {
   };
 }
 
-// Direct plugin function - takes options + sdk + context in one object
 export const listAppsPlugin: Plugin<
-  {}, // no SDK dependencies
-  { api: ApiClient }, // requires api in context
+  {},
+  GetContextType<ApiPluginProvides & ManifestPluginProvides>,
   ListAppsPluginProvides
 > = ({ context }) => {
   const listApps = createPaginatedFunction(async function listAppsPage(
@@ -38,9 +41,28 @@ export const listAppsPlugin: Plugin<
     const api = context.api;
     const opts = options;
 
-    const appKeys = [...(opts.appKeys ?? [])].map(
-      (key) => splitVersionedKey(key)[0],
-    );
+    const appLocators = await context.resolveAppKeys({
+      appKeys: [...(opts.appKeys ?? [])],
+    });
+    const implementationNameToLocator: Record<string, ResolvedAppLocator[]> =
+      {};
+    for (const locator of appLocators) {
+      implementationNameToLocator[locator.implementationName] = [
+        ...(implementationNameToLocator[locator.implementationName] ?? []),
+        locator,
+      ];
+    }
+    const duplicatedLookupAppKeys = Object.keys(implementationNameToLocator)
+      .filter((key) => implementationNameToLocator[key].length > 1)
+      .map((key) => implementationNameToLocator[key])
+      .flat()
+      .map((locator) => locator.lookupAppKey);
+
+    if (duplicatedLookupAppKeys.length > 0) {
+      throw new Error(
+        `Duplicate lookup app keys found: ${duplicatedLookupAppKeys.join(", ")}`,
+      );
+    }
 
     if (opts.search) {
       const searchParams: Record<string, string> = {};
@@ -58,12 +80,18 @@ export const listAppsPlugin: Plugin<
         normalizeImplementationMetaToAppItem,
       );
 
-      const appKeysSet = new Set(appKeys);
+      const implementationNameSet = new Set<string>(
+        appLocators.map((locator) => locator.implementationName),
+      );
 
       for (const implementation of implementations) {
-        if (!appKeysSet.has(implementation.key)) {
-          appKeysSet.add(implementation.key);
-          appKeys.push(implementation.key);
+        const [implementationName] = splitVersionedKey(implementation.key);
+        if (!implementationNameSet.has(implementationName)) {
+          implementationNameSet.add(implementationName);
+          appLocators.push({
+            ...toAppLocator(implementation.key),
+            implementationName,
+          });
         }
       }
     }
@@ -74,23 +102,17 @@ export const listAppsPlugin: Plugin<
       searchParams.limit = opts.pageSize.toString();
     }
 
-    searchParams.latest_only = "true";
+    if (appLocators.length === 0) {
+      searchParams.latest_only = "true";
+    }
 
     if (opts.cursor) {
       searchParams.offset = opts.cursor;
     }
 
-    if (appKeys.length > 0) {
-      const groupedAppKeys = groupAppKeysByType(appKeys);
-
-      if (groupedAppKeys.selectedApi.length > 0) {
-        searchParams.selected_apis = groupedAppKeys.selectedApi.join(",");
-      }
-
-      if (groupedAppKeys.slug.length > 0) {
-        searchParams.slugs = groupedAppKeys.slug.join(",");
-      }
-    }
+    searchParams.selected_apis = appLocators
+      .map((locator) => toImplementationId(locator))
+      .join(",");
 
     const implementationsEnvelope: ImplementationsMetaResponse = await api.get(
       "/api/v4/implementations-meta/lookup/",
@@ -114,7 +136,10 @@ export const listAppsPlugin: Plugin<
       meta: {
         listApps: {
           categories: ["app"],
+          type: "list",
+          itemType: "App",
           inputSchema: ListAppsSchema,
+          outputSchema: AppItemSchema,
         },
       },
     },

package/src/plugins/listApps/schemas.ts

@@ -2,8 +2,6 @@ import { z } from "zod";
 import type { AppItem } from "../../types/domain";
 import type { PaginatedSdkFunction } from "../../types/functions";
 import type { ZapierApiError, ZapierValidationError } from "../../types/errors";
-import { AppItemSchema } from "../../schemas/App";
-import { withOutputSchema } from "../../utils/schema-utils";
 
 // Union of all possible errors for listApps
 export type ListAppsError = ZapierApiError | ZapierValidationError;
@@ -15,30 +13,23 @@ export interface ListAppsPage {
 }
 
 // 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,
-);
+export const ListAppsSchema = 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");
 
 // Type inferred from schema
 export type ListAppsOptions = z.infer<typeof ListAppsSchema>;

package/src/plugins/listAuthentications/index.test.ts

@@ -6,7 +6,6 @@ import {
 import { listAuthenticationsPlugin } from "./index";
 import { createSdk } from "../../sdk";
 import type { ApiClient } from "../../api";
-import type { AppItem } from "../../types/domain";
 
 const mockAuthenticationsResponse = {
   results: [
@@ -42,15 +41,6 @@ const mockAuthenticationsResponse = {
   previous: null,
 };
 
-const mockSlackApp: AppItem = {
-  title: "Slack",
-  key: "SlackCLIAPI",
-  current_implementation_id: "SlackCLIAPI@1.21.1",
-  version: "1.21.1",
-  description: "Team communication platform",
-  slug: "slack",
-};
-
 describe("listAuthentications plugin", () => {
   let mockApiClient: ApiClient;
   let mockGetVersionedImplementationId: any;
@@ -72,15 +62,14 @@ describe("listAuthentications plugin", () => {
     },
   });
 
+  const mockResolveAppKeys = vi.fn().mockResolvedValue([]);
+
   const manifestPlugin = () => ({
     context: {
       manifest: null,
       getVersionedImplementationId: mockGetVersionedImplementationId,
-      getManifestEntry: () => ({
-        implementationName: "SlackCLIAPI",
-        version: "1.21.1",
-      }),
-      getImplementation: vi.fn().mockResolvedValue(mockSlackApp),
+      resolveAppKeys: mockResolveAppKeys,
+      updateManifestEntry: vi.fn().mockResolvedValue(["test-key", {}]),
     },
   });
 
@@ -152,6 +141,21 @@ describe("listAuthentications plugin", () => {
       }).toThrow(ZapierValidationError);
     });
 
+    it("should throw validation error for invalid authenticationIds type", () => {
+      const sdk = createTestSdk();
+      expect(() => {
+        sdk.listAuthentications({
+          authenticationIds: "123" as any, // Should be array of strings
+        });
+      }).toThrow(ZapierValidationError);
+
+      expect(() => {
+        sdk.listAuthentications({
+          authenticationIds: [123] as any, // Should be array of strings, not numbers
+        });
+      }).toThrow(ZapierValidationError);
+    });
+
     it("should throw validation error for invalid pageSize", () => {
       const sdk = createTestSdk();
       expect(() => {
@@ -186,6 +190,7 @@ describe("listAuthentications plugin", () => {
       const sdk = createTestSdk();
       const result = await sdk.listAuthentications({
         appKey: "slack",
+        authenticationIds: ["123", "456"],
         search: "workspace",
         title: "My Slack Workspace",
         accountId: "acc_123",
@@ -336,6 +341,38 @@ describe("listAuthentications plugin", () => {
         }),
       );
     });
+
+    it("should pass authenticationIds as ids parameter to API", async () => {
+      const sdk = createTestSdk();
+      await sdk.listAuthentications({
+        authenticationIds: ["123", "456", "789"],
+      });
+
+      expect(mockApiClient.get).toHaveBeenCalledWith(
+        "/api/v4/authentications/",
+        expect.objectContaining({
+          searchParams: expect.objectContaining({
+            ids: "123,456,789",
+          }),
+        }),
+      );
+    });
+
+    it("should not include ids parameter when authenticationIds is empty", async () => {
+      const sdk = createTestSdk();
+      await sdk.listAuthentications({
+        authenticationIds: [],
+      });
+
+      expect(mockApiClient.get).toHaveBeenCalledWith(
+        "/api/v4/authentications/",
+        expect.objectContaining({
+          searchParams: expect.not.objectContaining({
+            ids: expect.anything(),
+          }),
+        }),
+      );
+    });
   });
 
   describe("pagination", () => {

package/src/plugins/listAuthentications/index.ts

@@ -18,6 +18,8 @@ import {
 } from "../../utils/function-utils";
 import type { GetVersionedImplementationId } from "../manifest/schemas";
 import type { ManifestPluginProvides } from "../manifest";
+import { appKeyResolver } from "../../resolvers";
+import { AuthenticationItemSchema } from "../../schemas/Auth";
 
 export interface ListAuthenticationsPluginProvides {
   listAuthentications: (options?: ListAuthenticationsOptions) => Promise<{
@@ -36,11 +38,11 @@ export interface ListAuthenticationsPluginProvides {
 }
 
 export const listAuthenticationsPlugin: Plugin<
-  GetSdkType<ManifestPluginProvides>, // requires getApp in SDK
+  GetSdkType<ManifestPluginProvides>,
   {
     api: ApiClient;
     getVersionedImplementationId: GetVersionedImplementationId;
-  }, // requires api in context
+  },
   ListAuthenticationsPluginProvides
 > = ({ context }) => {
   const listAuthentications = createPaginatedFunction(
@@ -64,6 +66,11 @@ export const listAuthenticationsPlugin: Plugin<
         }
       }
 
+      // Add authenticationIds as ids parameter if provided
+      if (options.authenticationIds && options.authenticationIds.length > 0) {
+        searchParams.ids = options.authenticationIds.join(",");
+      }
+
       // Add other query parameters if provided
       // Use title as search if no explicit search provided
       if (options.search) {
@@ -130,7 +137,13 @@ export const listAuthenticationsPlugin: Plugin<
       meta: {
         listAuthentications: {
           categories: ["authentication"],
+          type: "list",
+          itemType: "Authentication",
           inputSchema: ListAuthenticationsSchema,
+          outputSchema: AuthenticationItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+          },
         },
       },
     },

package/src/plugins/listAuthentications/schemas.ts

@@ -16,6 +16,10 @@ export const ListAuthenticationsSchema = z
     appKey: AppKeyPropertySchema.optional().describe(
       "App key of authentications to list (e.g., 'SlackCLIAPI')",
     ),
+    authenticationIds: z
+      .array(z.string())
+      .optional()
+      .describe("List of authentication IDs to filter by"),
     search: z
       .string()
       .optional()

package/src/plugins/listInputFieldChoices/index.ts

@@ -10,10 +10,19 @@ import {
   ListInputFieldChoicesSchema,
   type ListInputFieldChoicesOptions,
   type ListInputFieldChoicesPage,
+  InputFieldChoiceItemSchema,
 } from "./schemas";
 import { ZapierApiError } from "../../types/errors";
 import { createPaginatedFunction } from "../../utils/function-utils";
 import type { GetActionPluginProvides } from "../getAction";
+import {
+  appKeyResolver,
+  actionTypeResolver,
+  actionKeyResolver,
+  authenticationIdResolver,
+  inputFieldKeyResolver,
+  inputsAllOptionalResolver,
+} from "../../resolvers";
 
 // Transform NeedChoices to InputFieldChoiceItem
 function transformNeedChoicesToInputFieldChoiceItem(
@@ -116,7 +125,7 @@ export const listInputFieldChoicesPlugin: Plugin<
 
     // Handle pagination
     let nextCursor: string | undefined;
-    if (choicesData.next_page !== undefined) {
+    if (choicesData.next_page != null) {
       nextCursor = choicesData.next_page.toString();
     } else if (choicesData.links?.next) {
       // Extract page from next URL for external actions
@@ -144,7 +153,18 @@ export const listInputFieldChoicesPlugin: Plugin<
       meta: {
         listInputFieldChoices: {
           categories: ["action"],
+          type: "list",
+          itemType: "InputFieldChoice",
           inputSchema: ListInputFieldChoicesSchema,
+          outputSchema: InputFieldChoiceItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+            authenticationId: authenticationIdResolver,
+            inputFieldKey: inputFieldKeyResolver,
+            inputs: inputsAllOptionalResolver,
+          },
         },
       },
     },

package/src/plugins/listInputFieldChoices/schemas.ts

@@ -6,7 +6,8 @@ import {
   ActionKeyPropertySchema,
   InputsPropertySchema,
 } from "../../types/properties";
-import { withFormatter, withOutputSchema } from "../../utils/schema-utils";
+import { withFormatter } from "../../utils/schema-utils";
+import { NeedChoicesSchema } from "../../api/schemas";
 import type { PaginatedSdkFunction } from "../../types/functions";
 import type {
   ZapierConfigurationError,
@@ -21,46 +22,33 @@ import type {
 // Input Field Choice Item Schema
 // ============================================================================
 
-export const InputFieldChoiceItemSchema = withFormatter(
-  z.object({
-    key: z.string().optional().describe("Unique key/value for the choice"),
-    label: z
-      .string()
-      .optional()
-      .describe("Human readable label for the choice"),
-    sample: z.string().optional().describe("Sample value for the choice"),
-    value: z
-      .string()
-      .optional()
-      .describe("Value to be submitted when selected"),
-  }),
-  {
-    format: (item) => {
-      const title = item.label || item.key || "Choice";
-      const subtitle =
-        item.label && item.key && item.label !== item.key
-          ? `(${item.key})`
-          : undefined;
-      const details: Array<{
-        text: string;
-        style: "success" | "dim" | "normal" | "accent" | "warning";
-      }> = [];
+export const InputFieldChoiceItemSchema = withFormatter(NeedChoicesSchema, {
+  format: (item) => {
+    const title = item.label || item.key || "Choice";
+    const details: Array<{
+      text: string;
+      style: "success" | "dim" | "normal" | "accent" | "warning";
+    }> = [];
+
+    // Show key as detail if different from label
+    if (item.label && item.key && item.label !== item.key) {
+      details.push({ text: `Key: ${item.key}`, style: "dim" });
+    }
 
-      if (item.sample && item.sample !== item.key) {
-        details.push({ text: `Sample: ${item.sample}`, style: "dim" });
-      }
-      if (item.value && item.value !== item.key) {
-        details.push({ text: `Value: ${item.value}`, style: "normal" });
-      }
+    if (item.sample && item.sample !== item.key) {
+      details.push({ text: `Sample: ${item.sample}`, style: "dim" });
+    }
+    if (item.value && item.value !== item.key) {
+      details.push({ text: `Value: ${item.value}`, style: "normal" });
+    }
 
-      return {
-        title,
-        subtitle,
-        details,
-      };
-    },
+    return {
+      title,
+      key: item.key,
+      details,
+    };
   },
-);
+});
 
 export type InputFieldChoiceItem = z.infer<typeof InputFieldChoiceItemSchema>;
 
@@ -68,47 +56,44 @@ export type InputFieldChoiceItem = z.infer<typeof InputFieldChoiceItemSchema>;
 // Plugin Schema Definition
 // ============================================================================
 
-export const ListInputFieldChoicesSchema = withOutputSchema(
-  z
-    .object({
-      // Required action identification
-      appKey: AppKeyPropertySchema,
-      actionType: ActionTypePropertySchema,
-      actionKey: ActionKeyPropertySchema,
+export const ListInputFieldChoicesSchema = z
+  .object({
+    // Required action identification
+    appKey: AppKeyPropertySchema,
+    actionType: ActionTypePropertySchema,
+    actionKey: ActionKeyPropertySchema,
 
-      // Input field specification
-      inputFieldKey: z
-        .string()
-        .min(1)
-        .describe("Input field key to get choices for."),
+    // Input field specification
+    inputFieldKey: z
+      .string()
+      .min(1)
+      .describe("Input field key to get choices for."),
 
-      // Common parameters
-      authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
-      inputs: InputsPropertySchema.optional().describe(
-        "Current input values that may affect available choices",
-      ),
-      page: z
-        .number()
-        .int()
-        .min(0)
-        .optional()
-        .describe("Page number for paginated results"),
+    // Common parameters
+    authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
+    inputs: InputsPropertySchema.optional().describe(
+      "Current input values that may affect available choices",
+    ),
+    page: z
+      .number()
+      .int()
+      .min(0)
+      .optional()
+      .describe("Page number for paginated results"),
 
-      // Pagination options (SDK-level)
-      pageSize: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Number of choices per page"),
-      maxItems: z
-        .number()
-        .min(1)
-        .optional()
-        .describe("Maximum total items to return across all pages"),
-    })
-    .describe("Get the available choices for a dynamic dropdown input field"),
-  InputFieldChoiceItemSchema,
-);
+    // Pagination options (SDK-level)
+    pageSize: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Number of choices per page"),
+    maxItems: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Maximum total items to return across all pages"),
+  })
+  .describe("Get the available choices for a dynamic dropdown input field");
 
 // Type inferred from schema
 export type ListInputFieldChoicesOptions = z.infer<

package/src/plugins/listInputFields/index.test.ts

@@ -217,7 +217,7 @@ describe("listInputFields plugin", () => {
       // Check message field transformation
       expect(result.data[0]).toEqual(
         expect.objectContaining({
-          id: "message",
+          key: "message",
           title: "Message",
           description: "The message to send",
           is_required: true,
@@ -227,26 +227,22 @@ describe("listInputFields plugin", () => {
         }),
       );
 
-      // Check channel field with choices (SELECT format)
+      // Check channel field with SELECT format
       expect(result.data[1]).toEqual(
         expect.objectContaining({
-          id: "channel",
+          key: "channel",
           title: "Channel",
           description: "The channel to send to",
           is_required: true,
           value_type: "STRING",
           format: "SELECT",
-          choices: [
-            { value: "#general", label: "General", sample: "#general" },
-            { value: "#random", label: "Random", sample: "#random" },
-          ],
         }),
       );
 
       // Check array field
       expect(result.data[2]).toEqual(
         expect.objectContaining({
-          id: "tags",
+          key: "tags",
           title: "Tags",
           description: "List of tags",
           value_type: "ARRAY",
@@ -405,7 +401,7 @@ describe("listInputFields plugin", () => {
       }
 
       expect(items).toHaveLength(3);
-      expect(items[0].id).toBe("message");
+      expect(items[0].key).toBe("message");
     });
   });
 });