@zapier/zapier-sdk 0.4.1 → 0.5.0

package/src/plugins/runAction/index.ts

@@ -0,0 +1,176 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { ApiClient } from "../../api";
+import {
+  RunActionSchema,
+  type RunActionOptions,
+  type RunActionPage,
+} from "./schemas";
+import {
+  ZapierValidationError,
+  ZapierConfigurationError,
+  ZapierActionError,
+} from "../../types/errors";
+import { createPaginatedFunction } from "../../utils/function-utils";
+import type { GetActionPluginProvides } from "../getAction";
+import type { GetAppPluginProvides } from "../getApp";
+
+export interface RunActionPluginProvides {
+  runAction: (options?: RunActionOptions) => Promise<{ data: any[] }> &
+    AsyncIterable<{ data: any[]; nextCursor?: string }> & {
+      items(): AsyncIterable<any>;
+    };
+  context: {
+    meta: {
+      runAction: {
+        inputSchema: typeof RunActionSchema;
+      };
+    };
+  };
+}
+
+interface ExecuteActionOptions {
+  api: ApiClient;
+  sdk: GetSdkType<GetActionPluginProvides & GetAppPluginProvides>;
+  appKey: string;
+  actionKey: string;
+  actionType: string;
+  executionOptions: { inputs: Record<string, unknown> };
+  authenticationId?: number | null;
+  options: RunActionOptions;
+}
+
+async function executeAction(actionOptions: ExecuteActionOptions): Promise<{
+  results: unknown[];
+  errors?: Array<{ detail?: string; title?: string }>;
+}> {
+  const {
+    api,
+    sdk,
+    appKey,
+    actionKey,
+    actionType,
+    executionOptions,
+    authenticationId,
+  } = actionOptions;
+
+  // Use the getApp plugin to get the current implementation ID
+  const appData = await sdk.getApp({ appKey });
+  const selectedApi = appData.data.current_implementation_id;
+
+  if (!selectedApi) {
+    throw new ZapierConfigurationError(
+      "No current_implementation_id found for app",
+      { configType: "current_implementation_id" },
+    );
+  }
+
+  // Step 1: POST to /actions/v1/runs to start execution
+  const runRequestData: {
+    selected_api: string;
+    action_key: string;
+    action_type: string;
+    inputs: Record<string, unknown>;
+    authentication_id?: number | null;
+  } = {
+    selected_api: selectedApi,
+    action_key: actionKey,
+    action_type: actionType,
+    inputs: executionOptions.inputs || {},
+  };
+
+  // Only include authentication_id if it's provided
+  if (authenticationId !== null && authenticationId !== undefined) {
+    runRequestData.authentication_id = authenticationId;
+  }
+
+  const runRequest = {
+    data: runRequestData,
+  };
+
+  const runData = await api.post("/api/actions/v1/runs", runRequest);
+  const runId = runData.data.id;
+
+  // Step 2: Poll GET /actions/v1/runs/{run_id} for results
+  return await api.poll(`/api/actions/v1/runs/${runId}`, {
+    successStatus: 200,
+    pendingStatus: 202,
+    resultExtractor: (result: { data: unknown }) => result.data,
+  });
+}
+
+export const runActionPlugin: Plugin<
+  GetSdkType<GetActionPluginProvides & GetAppPluginProvides>, // requires getAction and getApp in SDK
+  { api: ApiClient }, // requires api in context
+  RunActionPluginProvides
+> = ({ sdk, context }) => {
+  const runAction = createPaginatedFunction(async function runActionPage(
+    options: RunActionOptions & { cursor?: string } & { pageSize: number },
+  ): Promise<RunActionPage> {
+    const { api } = context;
+    const {
+      appKey,
+      actionKey,
+      actionType,
+      authenticationId,
+      inputs = {},
+    } = options;
+
+    // Validate that the action exists using the getAction plugin
+    const actionData = await sdk.getAction({
+      appKey: appKey,
+      actionKey: actionKey,
+      actionType: actionType,
+    });
+
+    // Validate action type matches
+    if (actionData.data.action_type !== actionType) {
+      throw new ZapierValidationError(
+        `Action type mismatch: expected ${actionType}, got ${actionData.data.action_type}`,
+      );
+    }
+
+    // Execute the action using the Actions API (supports all action types)
+    const result = await executeAction({
+      api,
+      sdk,
+      appKey,
+      actionKey,
+      actionType,
+      executionOptions: { inputs },
+      authenticationId,
+      options,
+    });
+
+    // Check for errors in the result and throw if present
+    if (result.errors && result.errors.length > 0) {
+      const errorMessage = result.errors
+        .map(
+          (error: { detail?: string; title?: string }) =>
+            error.detail || error.title || "Unknown error",
+        )
+        .join("; ");
+
+      throw new ZapierActionError(`Action execution failed: ${errorMessage}`, {
+        appKey,
+        actionKey,
+      });
+    }
+
+    // Return the results array wrapped in data with empty nextCursor (no pagination for action execution)
+    return {
+      data: result.results || [],
+      nextCursor: undefined, // No pagination implemented yet
+    };
+  }, RunActionSchema);
+
+  return {
+    runAction,
+    context: {
+      meta: {
+        runAction: {
+          inputSchema: RunActionSchema,
+        },
+      },
+    },
+  };
+};

package/src/plugins/runAction/schemas.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import {
+  AppKeyPropertySchema,
+  ActionTypePropertySchema,
+  ActionKeyPropertySchema,
+  AuthenticationIdPropertySchema,
+  InputsPropertySchema,
+} from "../../types/properties";
+import type { PaginatedSdkFunction } from "../../types/functions";
+
+// Pure Zod schema - no resolver metadata!
+export const RunActionSchema = z
+  .object({
+    appKey: AppKeyPropertySchema,
+    actionType: ActionTypePropertySchema,
+    actionKey: ActionKeyPropertySchema,
+    authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
+    inputs: InputsPropertySchema.optional().describe(
+      "Input parameters for the action",
+    ),
+    pageSize: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Number of results per page"),
+    maxItems: z
+      .number()
+      .min(1)
+      .optional()
+      .describe("Maximum total items to return across all pages"),
+  })
+  .describe("Execute an action with the given inputs");
+
+// Type inferred from schema
+export type RunActionOptions = z.infer<typeof RunActionSchema>;
+
+// Page result structure (for consistency with other paginated functions)
+export interface RunActionPage {
+  data: any[];
+  nextCursor?: string;
+}
+
+// Error union for this function
+export type RunActionError =
+  | import("../../types/errors").ZapierActionError
+  | import("../../types/errors").ZapierValidationError
+  | import("../../types/errors").ZapierConfigurationError
+  | import("../../types/errors").ZapierUnknownError;
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface RunActionSdkFunction {
+  runAction: PaginatedSdkFunction<RunActionOptions, any>;
+}

package/src/resolvers/actionKey.ts

@@ -14,9 +14,11 @@ export const actionKeyResolver: ActionKeyResolver = {
   type: "dynamic",
   depends: ["appKey", "actionType"] as const,
   fetch: async (sdk: ZapierSdk, resolvedParams: Record<string, any>) => {
-    const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
-    return actions.filter(
-      (action: any) => action.type === resolvedParams.actionType,
+    const actionsResponse = await sdk.listActions({
+      appKey: resolvedParams.appKey,
+    });
+    return actionsResponse.data.filter(
+      (action: any) => action.action_type === resolvedParams.actionType,
     );
   },
   prompt: (actions: any[]) => ({
@@ -24,7 +26,7 @@ export const actionKeyResolver: ActionKeyResolver = {
     name: "actionKey",
     message: "Select action:",
     choices: actions.map((action) => ({
-      name: `${action.name || action.key} - ${
+      name: `${action.title || action.name || action.key} - ${
         action.description || "No description"
       }`,
       value: action.key,

package/src/resolvers/actionType.ts

@@ -14,8 +14,13 @@ export const actionTypeResolver: ActionTypeResolver = {
   type: "dynamic",
   depends: ["appKey"] as const,
   fetch: async (sdk: ZapierSdk, resolvedParams: Record<string, any>) => {
-    const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
-    const types = [...new Set(actions.map((action: any) => action.type))];
+    const actionsResponse = await sdk.listActions({
+      appKey: resolvedParams.appKey,
+    });
+
+    const types = [
+      ...new Set(actionsResponse.data.map((action) => action.action_type)),
+    ];
     return types.map((type) => ({ key: type, name: type }));
   },
   prompt: (types: any[]) => ({

package/src/resolvers/appKey.ts

@@ -7,5 +7,5 @@ export interface AppKeyResolver {
 export const appKeyResolver: AppKeyResolver = {
   type: "static",
   inputType: "text",
-  placeholder: "Enter app slug (e.g., 'slack', 'github')",
+  placeholder: "Enter app key (e.g., 'SlackCLIAPI' or slug like 'github')",
 };

package/src/resolvers/authenticationId.ts

@@ -14,11 +14,20 @@ export const authenticationIdResolver: AuthenticationIdResolver = {
   type: "dynamic",
   depends: ["appKey"] as const,
   fetch: async (sdk: ZapierSdk, resolvedParams: Record<string, any>) => {
-    // Get auths for the specific app (owned auths will be prioritized automatically)
-    return await sdk.listAuthentications({
+    const myAuths = await sdk.listAuthentications({
       appKey: resolvedParams.appKey,
-      limit: 1000,
+      maxItems: 1000,
+      owner: "me",
     });
+    const allAuths = await sdk.listAuthentications({
+      appKey: resolvedParams.appKey,
+      maxItems: 1000,
+    });
+    // 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>) => ({
     type: "list",

package/src/resolvers/inputs.ts

@@ -13,11 +13,13 @@ export const inputsResolver: InputsResolver = {
   type: "fields",
   depends: ["appKey", "actionKey", "actionType", "authenticationId"] as const,
   fetch: async (sdk: ZapierSdk, resolvedParams: Record<string, any>) => {
-    return await sdk.listFields({
+    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;
   },
 };

package/src/schemas/Action.ts

@@ -1,31 +1,37 @@
 import { z } from "zod";
-import { withFormatter } from "../schema-utils";
+import { withFormatter } from "../utils/schema-utils";
+import { ActionSchema } from "../api/schemas";
 
 // ============================================================================
-// Action Schemas
+// Action Item Schema (extends API schema with computed fields and formatting)
 // ============================================================================
 
 export const ActionItemSchema = withFormatter(
-  z.object({
-    key: z.string(),
-    name: z.string().optional(),
-    type: z.string(),
-    appKey: z.string().optional(),
-    description: z.string().optional(),
+  ActionSchema.omit({ type: true, name: true }).extend({
+    app_key: z.string(), // Mapped from selected_api
+    action_type: ActionSchema.shape.type, // Mapped from original 'type' field
+    title: z.string(), // Mapped from original 'name' field
+    type: z.literal("action"), // Fixed type identifier
   }),
   {
     format: (item) => {
       const details = [];
-      details.push({ text: `Type: ${item.type}`, style: "accent" as const });
-      if (item.appKey) {
-        details.push({ text: `App: ${item.appKey}`, style: "normal" as const });
+      details.push({
+        text: `Type: ${item.action_type}`,
+        style: "accent" as const,
+      });
+      if (item.app_key) {
+        details.push({
+          text: `App: ${item.app_key}`,
+          style: "normal" as const,
+        });
       }
       if (item.description) {
         details.push({ text: item.description, style: "dim" as const });
       }
 
       return {
-        title: item.name || item.key,
+        title: item.title || item.name || item.key,
         subtitle: `(${item.key})`,
         details,
       };

package/src/schemas/App.ts

@@ -1,36 +1,28 @@
 import { z } from "zod";
-import { withFormatter } from "../schema-utils";
+import { withFormatter } from "../utils/schema-utils";
 
-export { FormattedItem, FormatMetadata } from "../schema-utils";
+export { FormattedItem, FormatMetadata } from "../utils/schema-utils";
 
 // ============================================================================
-// App Schemas
+// App Item Schema (extends API schema with computed fields and formatting)
 // ============================================================================
 
 export const AppItemSchema = withFormatter(
   z.object({
-    key: z.string(),
-    name: z.string().optional(),
+    // Essential properties only
+    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(),
-    category: z.string().optional(),
+    slug: z.string().optional(),
   }),
   {
     format: (item) => {
-      const details = [];
-      if (item.description) {
-        details.push({ text: item.description, style: "dim" as const });
-      }
-      if (item.category) {
-        details.push({
-          text: `Category: ${item.category}`,
-          style: "accent" as const,
-        });
-      }
-
       return {
-        title: item.name || item.key,
+        title: item.title,
         subtitle: `(${item.key})`,
-        details,
+        details: [],
       };
     },
   },

package/src/schemas/Auth.ts

@@ -1,20 +1,22 @@
 import { z } from "zod";
-import { withFormatter } from "../schema-utils";
+import { withFormatter } from "../utils/schema-utils";
+import { AuthenticationSchema } from "../api/schemas";
 
 // ============================================================================
-// Auth Schemas
+// Authentication Item Schema (extends API schema with computed fields and formatting)
 // ============================================================================
 
-export const AuthItemSchema = withFormatter(
-  z.object({
-    id: z.number(),
-    title: z.string().optional(),
-    identifier: z.string().optional(),
-    account_id: z.string().optional(),
-    is_private: z.boolean().optional(),
-    shared_with_all: z.boolean().optional(),
-    marked_stale_at: z.string().optional(),
-  }),
+export const AuthenticationItemSchema = withFormatter(
+  AuthenticationSchema.omit({ selected_api: true, customuser_id: true }).extend(
+    {
+      implementation_id: z.string().optional(), // Renamed from selected_api
+      is_expired: z.string().optional(), // Mapped from is_stale
+      expired_at: z.string().nullable().optional(), // Mapped from marked_stale_at
+      app_key: z.string().optional(), // App key from implementations endpoint
+      version: z.string().optional(), // Version extracted from implementation_id
+      user_id: z.number().optional(),
+    },
+  ),
   {
     format: (item) => {
       const details = [];
@@ -27,7 +29,7 @@ export const AuthItemSchema = withFormatter(
       }
 
       details.push({
-        text: `Account: ${item.account_id || "unknown"} | Private: ${item.is_private || false} | Shared: ${item.shared_with_all || false}`,
+        text: `Account: ${item.account_id} | Private: ${item.is_private} | Shared: ${item.shared_with_all}`,
         style: "dim" as const,
       });
 
@@ -47,6 +49,9 @@ export const AuthItemSchema = withFormatter(
   },
 );
 
+// Legacy alias for backward compatibility
+export const AuthItemSchema = AuthenticationItemSchema;
+
 // ============================================================================
 // Type Exports
 // ============================================================================

package/src/schemas/Field.ts

@@ -1,25 +1,117 @@
 import { z } from "zod";
-import { withFormatter } from "../schema-utils";
+import { withFormatter } from "../utils/schema-utils";
+import { NeedSchema } from "../api/schemas";
 
 // ============================================================================
-// Field Schemas
+// Input Field Item Schema (extends API Need schema with computed fields and formatting)
 // ============================================================================
 
-export const FieldItemSchema = withFormatter(
-  z.object({
-    key: z.string(),
-    name: z.string().optional(),
-    description: z.string().optional(),
+export const InputFieldItemSchema = withFormatter(
+  NeedSchema.omit({
+    depends_on: true,
+    placeholder: true,
+    required: true,
+    format: true,
+  }).extend({
+    id: z.string(), // Mapped from 'key'
+    default_value: z.string(), // Mapped from 'default' with fallback to ""
+    depends_on: z.array(z.string()), // Override: mapped from 'depends_on' with fallback to []
+    description: z.string(), // Mapped from 'help_text' with fallback to ""
+    invalidates_input_fields: z.boolean(), // Mapped from 'alters_custom_fields' with fallback to false
+    is_required: z.boolean(), // Override: mapped from 'required' with fallback to false
+    placeholder: z.string(), // Override: mapped from 'placeholder' with fallback to ""
+    title: z.string(), // Mapped from 'label' with fallback to ""
+    value_type: z.string(), // Computed from InputFieldType enum
+    format: z.string().optional(), // Override: computed from InputFieldFormat enum (optional)
+    items: z.object({ type: z.string() }).optional(), // Computed from ItemsType enum (optional, only for arrays)
   }),
   {
     format: (item) => {
       const details = [];
-      if (item.description) {
-        details.push({ text: item.description, style: "dim" as const });
+
+      // Type and required status
+      const typeInfo = [
+        item.type && `Type: ${item.type}`,
+        `Required: ${item.required ? "Yes" : "No"}`,
+      ]
+        .filter(Boolean)
+        .join(" | ");
+      if (typeInfo) {
+        details.push({ text: typeInfo, style: "dim" as const });
+      }
+
+      // Help text
+      if (item.helpText) {
+        details.push({ text: item.helpText, style: "normal" as const });
+      }
+
+      // Default value
+      if (item.default !== undefined) {
+        details.push({
+          text: `Default: ${item.default}`,
+          style: "accent" as const,
+        });
+      }
+
+      // Placeholder
+      if (item.placeholder) {
+        details.push({
+          text: `Placeholder: ${item.placeholder}`,
+          style: "dim" as const,
+        });
+      }
+
+      // Choices
+      if (item.choices && item.choices.length > 0) {
+        const choiceText =
+          item.choices.length <= 3
+            ? `Choices: ${item.choices.map((c: any) => c.label || c.value).join(", ")}`
+            : `Choices: ${item.choices
+                .slice(0, 3)
+                .map((c: any) => c.label || c.value)
+                .join(", ")} (+${item.choices.length - 3} more)`;
+        details.push({ text: choiceText, style: "accent" as const });
+      }
+
+      // Dependencies
+      if (item.dependsOn && item.dependsOn.length > 0) {
+        details.push({
+          text: `Depends on: ${item.dependsOn.join(", ")}`,
+          style: "warning" as const,
+        });
+      }
+
+      // Format information
+      if (item.format) {
+        details.push({ text: `Format: ${item.format}`, style: "dim" as const });
+      }
+
+      // Input format
+      if (item.inputFormat && item.inputFormat.length > 0) {
+        details.push({
+          text: `Input formats: ${item.inputFormat.join(", ")}`,
+          style: "dim" as const,
+        });
+      }
+
+      // Special field flags
+      const flags = [];
+      if (item.computed) flags.push("computed");
+      if (item.customField) flags.push("custom");
+      if (flags.length > 0) {
+        details.push({
+          text: `Flags: ${flags.join(", ")}`,
+          style: "success" as const,
+        });
+      }
+
+      // Backwards compatibility: show description if no helpText
+      if (item.description && !item.helpText) {
+        details.push({ text: item.description, style: "normal" as const });
       }
 
       return {
-        title: item.name || item.key,
+        title: item.label || item.name || item.key,
         subtitle: `(${item.key})`,
         details,
       };
@@ -31,4 +123,7 @@ export const FieldItemSchema = withFormatter(
 // Type Exports
 // ============================================================================
 
-export type FieldItem = z.infer<typeof FieldItemSchema>;
+export type InputFieldItem = z.infer<typeof InputFieldItemSchema>;
+
+// Legacy alias for backward compatibility
+export type FieldItem = InputFieldItem;

package/src/schemas/UserProfile.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { withFormatter } from "../utils/schema-utils";
+import { UserProfileSchema } from "../api/schemas";
+
+export { FormattedItem, FormatMetadata } from "../utils/schema-utils";
+
+// ============================================================================
+// User Profile Item Schema (extends API schema with computed fields and formatting)
+// ============================================================================
+
+export const UserProfileItemSchema = withFormatter(
+  UserProfileSchema.omit({ user_id: true }).extend({
+    full_name: z.string(), // Computed field: first_name + " " + last_name
+  }),
+  {
+    format: (item) => {
+      const details = [];
+      details.push({ text: item.email, style: "dim" as const });
+      if (item.timezone) {
+        details.push({
+          text: `Timezone: ${item.timezone}`,
+          style: "accent" as const,
+        });
+      }
+      details.push({
+        text: `Member since: ${item.since_signup}`,
+        style: "dim" as const,
+      });
+
+      return {
+        title: item.full_name,
+        subtitle: `@${item.username}`,
+        details,
+      };
+    },
+  },
+);
+
+// ============================================================================
+// Type Exports
+// ============================================================================
+
+export type UserProfileItem = z.infer<typeof UserProfileItemSchema>;