@zapier/zapier-sdk 0.9.0 → 0.10.0

package/src/plugins/listInputFields/index.ts

@@ -11,6 +11,14 @@ import { ZapierConfigurationError, ZapierApiError } from "../../types/errors";
 import { createPaginatedFunction } from "../../utils/function-utils";
 import type { GetAppPluginProvides } from "../getApp";
 import type { GetVersionedImplementationId } from "../manifest/schemas";
+import {
+  appKeyResolver,
+  actionTypeResolver,
+  actionKeyResolver,
+  authenticationIdResolver,
+  inputsAllOptionalResolver,
+} from "../../resolvers";
+import { InputFieldItemSchema } from "../../schemas/Field";
 
 // Enums for input field transformation
 enum InputFieldType {
@@ -93,8 +101,8 @@ function transformNeedToInputFieldItem(need: Need): InputFieldItem {
   const itemsType = getItemsTypeFromNeed(need);
 
   return {
-    ...need, // Pass through all original Need fields
-    id: need.key,
+    // Only the final computed/mapped fields that are in InputFieldItemSchema
+    key: need.key,
     default_value: need.default || "",
     depends_on: need.depends_on || [],
     description: need.help_text || "",
@@ -200,7 +208,17 @@ export const listInputFieldsPlugin: Plugin<
       meta: {
         listInputFields: {
           categories: ["action"],
+          type: "list",
+          itemType: "InputField",
           inputSchema: ListInputFieldsSchema,
+          outputSchema: InputFieldItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+            authenticationId: authenticationIdResolver,
+            inputs: inputsAllOptionalResolver,
+          },
         },
       },
     },

package/src/plugins/registry/index.ts

@@ -55,10 +55,16 @@ export const registryPlugin: Plugin<
   const functions = metaKeys
     .filter((key) => typeof sdk[key as keyof typeof sdk] === "function")
     .map((key) => {
+      const meta = context.meta[key];
       return {
-        ...context.meta[key],
-        categories: context.meta[key].categories || [],
         name: key,
+        type: meta.type,
+        itemType: meta.itemType,
+        returnType: meta.returnType,
+        inputSchema: meta.inputSchema,
+        outputSchema: meta.outputSchema,
+        categories: meta.categories || [],
+        resolvers: meta.resolvers,
       };
     })
     .sort((a, b) => a.name.localeCompare(b.name));

package/src/plugins/request/index.ts

@@ -96,6 +96,7 @@ export const requestPlugin: Plugin<
       meta: {
         request: {
           categories: ["http"],
+          returnType: "Response",
           inputSchema: RelayRequestSchema,
         },
       },

package/src/plugins/runAction/index.ts

@@ -5,6 +5,7 @@ import {
   type RunActionOptions,
   type RunActionPage,
 } from "./schemas";
+import { ActionResultItemSchema } from "../../schemas/Run";
 import {
   ZapierValidationError,
   ZapierConfigurationError,
@@ -13,6 +14,13 @@ import {
 import { createPaginatedFunction } from "../../utils/function-utils";
 import type { GetActionPluginProvides } from "../getAction";
 import type { GetAppPluginProvides } from "../getApp";
+import {
+  appKeyResolver,
+  actionTypeResolver,
+  actionKeyResolver,
+  authenticationIdResolver,
+  inputsResolver,
+} from "../../resolvers";
 import type { GetVersionedImplementationId } from "../manifest/schemas";
 
 export interface RunActionPluginProvides {
@@ -177,7 +185,17 @@ export const runActionPlugin: Plugin<
       meta: {
         runAction: {
           categories: ["action"],
+          type: "list",
+          itemType: "ActionResult",
           inputSchema: RunActionSchema,
+          outputSchema: ActionResultItemSchema,
+          resolvers: {
+            appKey: appKeyResolver,
+            actionType: actionTypeResolver,
+            actionKey: actionKeyResolver,
+            authenticationId: authenticationIdResolver,
+            inputs: inputsResolver,
+          },
         },
       },
     },

package/src/resolvers/actionKey.ts

@@ -1,27 +1,29 @@
-import type { ZapierSdk } from "../types/sdk";
+import type { DynamicResolver } from "../utils/schema-utils";
+import type { ActionTypeProperty } from "../types/properties";
 
-export interface ActionKeyResolver {
-  type: "dynamic";
-  depends: readonly string[];
-  fetch: (
-    sdk: ZapierSdk,
-    resolvedParams: Record<string, any>,
-  ) => Promise<any[]>;
-  prompt: (items: any[], params: Record<string, any>) => any;
+interface ActionItem {
+  key: string;
+  title?: string;
+  name?: string;
+  description?: string;
+  action_type: string;
 }
 
-export const actionKeyResolver: ActionKeyResolver = {
+export const actionKeyResolver: DynamicResolver<
+  ActionItem,
+  { appKey: string; actionType: ActionTypeProperty }
+> = {
   type: "dynamic",
   depends: ["appKey", "actionType"] as const,
-  fetch: async (sdk: ZapierSdk, resolvedParams: Record<string, any>) => {
+  fetch: async (sdk, resolvedParams) => {
     const actionsResponse = await sdk.listActions({
       appKey: resolvedParams.appKey,
     });
     return actionsResponse.data.filter(
-      (action: any) => action.action_type === resolvedParams.actionType,
+      (action: ActionItem) => action.action_type === resolvedParams.actionType,
     );
   },
-  prompt: (actions: any[]) => ({
+  prompt: (actions) => ({
     type: "list",
     name: "actionKey",
     message: "Select action:",

package/src/resolvers/actionType.ts

@@ -1,19 +1,17 @@
-import type { ZapierSdk } from "../types/sdk";
+import type { DynamicResolver } from "../utils/schema-utils";
 
-export interface ActionTypeResolver {
-  type: "dynamic";
-  depends: readonly string[];
-  fetch: (
-    sdk: ZapierSdk,
-    resolvedParams: Record<string, any>,
-  ) => Promise<any[]>;
-  prompt: (items: any[], params: Record<string, any>) => any;
+interface ActionTypeItem {
+  key: string;
+  name: string;
 }
 
-export const actionTypeResolver: ActionTypeResolver = {
+export const actionTypeResolver: DynamicResolver<
+  ActionTypeItem,
+  { appKey: string }
+> = {
   type: "dynamic",
   depends: ["appKey"] as const,
-  fetch: async (sdk: ZapierSdk, resolvedParams: Record<string, any>) => {
+  fetch: async (sdk, resolvedParams) => {
     const actionsResponse = await sdk.listActions({
       appKey: resolvedParams.appKey,
     });
@@ -23,7 +21,7 @@ export const actionTypeResolver: ActionTypeResolver = {
     ];
     return types.map((type) => ({ key: type, name: type }));
   },
-  prompt: (types: any[]) => ({
+  prompt: (types) => ({
     type: "list",
     name: "actionType",
     message: "Select action type:",

package/src/resolvers/appKey.ts

@@ -1,10 +1,6 @@
-export interface AppKeyResolver {
-  type: "static";
-  inputType?: "text" | "password" | "email";
-  placeholder?: string;
-}
+import type { StaticResolver } from "../utils/schema-utils";
 
-export const appKeyResolver: AppKeyResolver = {
+export const appKeyResolver: StaticResolver = {
   type: "static",
   inputType: "text",
   placeholder: "Enter app key (e.g., 'SlackCLIAPI' or slug like 'github')",

package/src/resolvers/authenticationId.ts

@@ -1,38 +1,38 @@
-import type { ZapierSdk } from "../types/sdk";
+import type { DynamicResolver } from "../utils/schema-utils";
+import type { AuthItem } from "../schemas/Auth";
 
-export interface AuthenticationIdResolver {
-  type: "dynamic";
-  depends: readonly string[];
-  fetch: (
-    sdk: ZapierSdk,
-    resolvedParams: Record<string, any>,
-  ) => Promise<any[]>;
-  prompt: (items: any[], params: Record<string, any>) => any;
-}
+type AuthenticationIdResolver = DynamicResolver<AuthItem, { appKey?: string }>;
 
 export const authenticationIdResolver: AuthenticationIdResolver = {
   type: "dynamic",
   depends: ["appKey"] as const,
-  fetch: async (sdk: ZapierSdk, resolvedParams: Record<string, any>) => {
-    const myAuths = await sdk.listAuthentications({
-      appKey: resolvedParams.appKey,
+  fetch: async (sdk, resolvedParams) => {
+    const listOptions: { maxItems: number; appKey?: string } = {
       maxItems: 1000,
+    };
+
+    if (resolvedParams.appKey) {
+      listOptions.appKey = resolvedParams.appKey;
+    }
+
+    const myAuths = await sdk.listAuthentications({
+      ...listOptions,
       owner: "me",
     });
-    const allAuths = await sdk.listAuthentications({
-      appKey: resolvedParams.appKey,
-      maxItems: 1000,
-    });
+    const allAuths = await sdk.listAuthentications(listOptions);
+
     // Filter out myAuths from allAuths
     const otherAuths = allAuths.data.filter(
       (auth) => !myAuths.data.some((myAuth) => myAuth.id === auth.id),
     );
     return [...myAuths.data, ...otherAuths];
   },
-  prompt: (auths: any[], params: Record<string, any>) => ({
+  prompt: (auths, params) => ({
     type: "list",
     name: "authenticationId",
-    message: `Select authentication for ${params.appKey}:`,
+    message: params.appKey
+      ? `Select authentication for ${params.appKey}:`
+      : "Select authentication:",
     choices: [
       ...auths.map((auth) => ({
         name: `${auth.title || auth.label || "Authentication"} (ID: ${auth.id})`,
@@ -45,3 +45,9 @@ export const authenticationIdResolver: AuthenticationIdResolver = {
     ],
   }),
 };
+
+// Generic version without appKey dependency
+export const authenticationIdGenericResolver: AuthenticationIdResolver = {
+  ...authenticationIdResolver,
+  depends: [] as const,
+};

package/src/resolvers/index.ts

@@ -1,117 +1,11 @@
-import { appKeyResolver } from "./appKey";
-import { actionTypeResolver } from "./actionType";
-import { actionKeyResolver } from "./actionKey";
-import { authenticationIdResolver } from "./authenticationId";
-import { inputsResolver } from "./inputs";
-
-// Centralized resolver registry
-export const resolverRegistry = {
-  appKey: appKeyResolver,
-  actionType: actionTypeResolver,
-  actionKey: actionKeyResolver,
-  authenticationId: authenticationIdResolver,
-  inputs: inputsResolver,
-} as const;
-
-// Type definitions
-export type ResolverName = keyof typeof resolverRegistry;
-export type ResolverType = (typeof resolverRegistry)[ResolverName];
-
-// Utility functions for working with resolvers
-
-/**
- * Get a resolver by name
- */
-export function getResolver(name: string): ResolverType | undefined {
-  return resolverRegistry[name as ResolverName];
-}
-
-/**
- * Get all resolvers for a list of missing parameters
- */
-export function getResolversForMissingParams(
-  missingParams: string[],
-): Record<string, ResolverType> {
-  const resolvers: Record<string, ResolverType> = {};
-
-  for (const param of missingParams) {
-    const resolver = resolverRegistry[param as ResolverName];
-    if (resolver) {
-      resolvers[param] = resolver;
-    }
-  }
-
-  return resolvers;
-}
-
-/**
- * Check if a parameter has a resolver
- */
-export function hasResolver(paramName: string): boolean {
-  return paramName in resolverRegistry;
-}
-
-/**
- * Get all parameter names that have resolvers
- */
-export function getResolvableParams(): string[] {
-  return Object.keys(resolverRegistry);
-}
-
-/**
- * Resolve dependency chain for a parameter
- * Returns parameters in the order they need to be resolved
- */
-export function getResolutionOrder(
-  paramName: string,
-  resolved: Set<string> = new Set(),
-): string[] {
-  const resolver = getResolver(paramName);
-  if (!resolver || resolver.type === "static") {
-    return [paramName];
-  }
-
-  const order: string[] = [];
-
-  if ("depends" in resolver && resolver.depends) {
-    for (const dependency of resolver.depends) {
-      if (!resolved.has(dependency)) {
-        order.push(...getResolutionOrder(dependency, resolved));
-        resolved.add(dependency);
-      }
-    }
-  }
-
-  if (!resolved.has(paramName)) {
-    order.push(paramName);
-    resolved.add(paramName);
-  }
-
-  return order;
-}
-
-/**
- * Get resolution order for multiple parameters
- */
-export function getResolutionOrderForParams(paramNames: string[]): string[] {
-  const resolved = new Set<string>();
-  const order: string[] = [];
-
-  for (const paramName of paramNames) {
-    const paramOrder = getResolutionOrder(paramName, resolved);
-    for (const param of paramOrder) {
-      if (!order.includes(param)) {
-        order.push(param);
-      }
-    }
-  }
-
-  return order;
-}
-
-// Re-export individual resolvers for direct access if needed
+// Re-export individual resolvers for plugin use
 export { appKeyResolver } from "./appKey";
 export { actionTypeResolver } from "./actionType";
 export { actionKeyResolver } from "./actionKey";
-export { authenticationIdResolver } from "./authenticationId";
+export {
+  authenticationIdResolver,
+  authenticationIdGenericResolver,
+} from "./authenticationId";
 export { inputsResolver } from "./inputs";
+export { inputFieldKeyResolver } from "./inputFieldKey";
+export { inputsAllOptionalResolver } from "./inputs";

package/src/resolvers/inputFieldKey.ts

@@ -0,0 +1,38 @@
+import type { DynamicResolver } from "../utils/schema-utils";
+import type { InputFieldItem } from "../schemas/Field";
+import type { ActionTypeProperty } from "../types/properties";
+
+export const inputFieldKeyResolver: DynamicResolver<
+  InputFieldItem,
+  {
+    appKey: string;
+    actionKey: string;
+    actionType: ActionTypeProperty;
+    authenticationId: number;
+    inputs?: Record<string, unknown>;
+  }
+> = {
+  type: "dynamic",
+  depends: ["appKey", "actionKey", "actionType", "authenticationId"] as const,
+  fetch: async (sdk, resolvedParams) => {
+    const fieldsResponse = await sdk.listInputFields({
+      appKey: resolvedParams.appKey,
+      actionKey: resolvedParams.actionKey,
+      actionType: resolvedParams.actionType,
+      authenticationId: resolvedParams.authenticationId,
+      inputs: resolvedParams.inputs, // Pass along currently resolved inputs
+    });
+    return fieldsResponse.data;
+  },
+  prompt: (fields) => ({
+    type: "list",
+    name: "inputFieldKey",
+    message: "Select input field:",
+    choices: fields.map((field) => ({
+      name: `${field.title || field.key} - ${
+        field.value_type || "No type"
+      } ${field.is_required ? "(required)" : "(optional)"}`,
+      value: field.key,
+    })),
+  }),
+};

package/src/resolvers/inputs.ts

@@ -1,18 +1,18 @@
-import type { ZapierSdk } from "../types/sdk";
+import type { FieldsResolver } from "../utils/schema-utils";
+import type { ActionTypeProperty } from "../types/properties";
 
-export interface InputsResolver {
-  type: "fields";
-  depends: readonly string[];
-  fetch: (
-    sdk: ZapierSdk,
-    resolvedParams: Record<string, any>,
-  ) => Promise<any[]>;
-}
+type InputsResolver = FieldsResolver<{
+  appKey: string;
+  actionKey: string;
+  actionType: ActionTypeProperty;
+  authenticationId: number;
+  inputs?: Record<string, unknown>;
+}>;
 
 export const inputsResolver: InputsResolver = {
   type: "fields",
   depends: ["appKey", "actionKey", "actionType", "authenticationId"] as const,
-  fetch: async (sdk: ZapierSdk, resolvedParams: Record<string, any>) => {
+  fetch: async (sdk, resolvedParams) => {
     const fieldsResponse = await sdk.listInputFields({
       appKey: resolvedParams.appKey,
       actionKey: resolvedParams.actionKey,
@@ -23,3 +23,21 @@ export const inputsResolver: InputsResolver = {
     return fieldsResponse.data;
   },
 };
+
+export const inputsAllOptionalResolver: InputsResolver = {
+  type: "fields",
+  depends: ["appKey", "actionKey", "actionType", "authenticationId"] as const,
+  fetch: async (sdk, resolvedParams) => {
+    const fieldsResponse = await sdk.listInputFields({
+      appKey: resolvedParams.appKey,
+      actionKey: resolvedParams.actionKey,
+      actionType: resolvedParams.actionType,
+      authenticationId: resolvedParams.authenticationId,
+      inputs: resolvedParams.inputs, // Pass along currently resolved inputs
+    });
+    return fieldsResponse.data.map((field) => ({
+      ...field,
+      is_required: false,
+    }));
+  },
+};

package/src/schemas/Action.ts

@@ -27,12 +27,17 @@ export const ActionItemSchema = withFormatter(
         });
       }
       if (item.description) {
-        details.push({ text: item.description, style: "dim" as const });
+        details.push({
+          text: item.description,
+          style: "dim" as const,
+        });
       }
 
       return {
-        title: item.title || item.name || item.key,
-        subtitle: `(${item.key})`,
+        title: item.title || item.key,
+        id: item.id,
+        key: item.key,
+        description: item.description,
         details,
       };
     },

package/src/schemas/App.ts

@@ -1,27 +1,25 @@
 import { z } from "zod";
 import { withFormatter } from "../utils/schema-utils";
+import { ImplementationMetaSchema } from "../api/schemas";
 
 export { FormattedItem, FormatMetadata } from "../utils/schema-utils";
 
 // ============================================================================
-// App Item Schema (extends API schema with computed fields and formatting)
+// App Item Schema (extends ImplementationMetaSchema with transformed fields)
 // ============================================================================
 
 export const AppItemSchema = withFormatter(
-  z.object({
-    // Essential properties only
+  ImplementationMetaSchema.omit({ name: true, id: true }).extend({
     title: z.string(), // Mapped from name
-    key: z.string(), // Mapped from selected_api
-    current_implementation_id: z.string(), // From id, keeps the full version
-    version: z.string().optional(), // Extracted from implementation ID
-    description: z.string().optional(),
-    slug: z.string().optional(),
+    key: z.string(), // Extracted from id (base part without version)
+    implementation_id: z.string(), // Mapped from id (full versioned ID)
   }),
   {
     format: (item) => {
       return {
         title: item.title,
-        subtitle: `(${item.key})`,
+        key: item.key,
+        description: item.description,
         details: [],
       };
     },

package/src/schemas/Auth.ts

@@ -42,7 +42,7 @@ export const AuthenticationItemSchema = withFormatter(
 
       return {
         title: item.title || `Authentication ${item.id}`,
-        subtitle: `(ID: ${item.id})`,
+        id: item.id?.toString(),
         details,
       };
     },