@zapier/zapier-sdk 0.8.3 → 0.10.0

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,
       };
     },

package/src/schemas/Field.ts

@@ -1,28 +1,22 @@
 import { z } from "zod";
 import { withFormatter } from "../utils/schema-utils";
-import { NeedSchema } from "../api/schemas";
 
 // ============================================================================
 // Input Field Item Schema (extends API Need schema with computed fields and formatting)
 // ============================================================================
 
 export const InputFieldItemSchema = withFormatter(
-  NeedSchema.omit({
-    depends_on: true,
-    placeholder: true,
-    required: true,
-    format: true,
-  }).extend({
-    id: z.string(), // Mapped from 'key'
+  z.object({
+    key: z.string(), // From need.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 []
+    depends_on: z.array(z.string()), // 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 ""
+    is_required: z.boolean(), // Mapped from 'required' with fallback to false
+    placeholder: z.string(), // 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)
+    format: z.string().optional(), // Computed from InputFieldFormat enum (optional)
     items: z.object({ type: z.string() }).optional(), // Computed from ItemsType enum (optional, only for arrays)
   }),
   {
@@ -31,8 +25,8 @@ export const InputFieldItemSchema = withFormatter(
 
       // Type and required status
       const typeInfo = [
-        item.type && `Type: ${item.type}`,
-        `Required: ${item.required ? "Yes" : "No"}`,
+        item.value_type && `Type: ${item.value_type}`,
+        `Required: ${item.is_required ? "Yes" : "No"}`,
       ]
         .filter(Boolean)
         .join(" | ");
@@ -40,15 +34,18 @@ export const InputFieldItemSchema = withFormatter(
         details.push({ text: typeInfo, style: "dim" as const });
       }
 
-      // Help text
-      if (item.helpText) {
-        details.push({ text: item.helpText, style: "normal" as const });
+      // Description
+      if (item.description) {
+        details.push({
+          text: item.description,
+          style: "normal" as const,
+        });
       }
 
       // Default value
-      if (item.default !== undefined) {
+      if (item.default_value) {
         details.push({
-          text: `Default: ${item.default}`,
+          text: `Default: ${item.default_value}`,
           style: "accent" as const,
         });
       }
@@ -61,25 +58,10 @@ export const InputFieldItemSchema = withFormatter(
         });
       }
 
-      // Choices
-      if (item.choices && item.choices.length > 0) {
-        const choiceText =
-          item.choices.length <= 3
-            ? `Choices: ${item.choices.map((c: { label?: string; value: string | number }) => c.label || c.value).join(", ")}`
-            : `Choices: ${item.choices
-                .slice(0, 3)
-                .map(
-                  (c: { label?: string; value: string | number }) =>
-                    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) {
+      if (item.depends_on && item.depends_on.length > 0) {
         details.push({
-          text: `Depends on: ${item.dependsOn.join(", ")}`,
+          text: `Depends on: ${item.depends_on.join(", ")}`,
           style: "warning" as const,
         });
       }
@@ -89,33 +71,18 @@ export const InputFieldItemSchema = withFormatter(
         details.push({ text: `Format: ${item.format}`, style: "dim" as const });
       }
 
-      // Input format
-      if (item.inputFormat && item.inputFormat.length > 0) {
+      // Items type for arrays
+      if (item.items) {
         details.push({
-          text: `Input formats: ${item.inputFormat.join(", ")}`,
+          text: `Items type: ${item.items.type}`,
           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.label || item.name || item.key,
-        subtitle: `(${item.key})`,
+        title: item.title || item.key,
+        key: item.key,
+        description: item.description,
         details,
       };
     },

package/src/schemas/Run.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { withFormatter, type FormattedItem } from "../utils/schema-utils";
+
+// Type guard to safely access object properties
+function getStringProperty(obj: unknown, key: string): string | undefined {
+  if (typeof obj === "object" && obj !== null && key in obj) {
+    const value = (obj as Record<string, unknown>)[key];
+    return typeof value === "string" ? value : undefined;
+  }
+  return undefined;
+}
+
+// Formatter for action results - handles any data structure
+function formatActionResult(item: unknown): FormattedItem {
+  // Try to extract common fields for structured display
+  const obj = typeof item === "object" && item !== null ? item : {};
+
+  // Try common title fields
+  const title =
+    getStringProperty(obj, "title") ||
+    getStringProperty(obj, "name") ||
+    getStringProperty(obj, "label") ||
+    getStringProperty(obj, "subject") ||
+    "Action Result";
+
+  return {
+    title,
+    id: getStringProperty(obj, "id"),
+    key: getStringProperty(obj, "key"),
+    description: getStringProperty(obj, "description"),
+    data: item, // Let formatJsonOutput handle the JSON rendering
+    details: [], // Not used when data is provided
+  };
+}
+
+// Flexible schema for action results - can be any object
+export const ActionResultItemSchema = withFormatter(
+  z.unknown().describe("Action execution result"),
+  { format: formatActionResult },
+);

package/src/schemas/UserProfile.ts

@@ -15,21 +15,38 @@ export const UserProfileItemSchema = withFormatter(
   {
     format: (item) => {
       const details = [];
-      details.push({ text: item.email, style: "dim" as const });
-      if (item.timezone) {
+      if (
+        item == null ||
+        typeof item !== "object" ||
+        !("full_name" in item) ||
+        !("username" in item)
+      ) {
+        return {
+          title: "User Profile",
+          subtitle: "Malformatted result item",
+          details: [],
+        };
+      }
+
+      if ("email" in item) {
+        details.push({ text: item.email, style: "dim" as const });
+      }
+      if ("timezone" in item && item.timezone) {
         details.push({
           text: `Timezone: ${item.timezone}`,
           style: "accent" as const,
         });
       }
-      details.push({
-        text: `Member since: ${item.since_signup}`,
-        style: "dim" as const,
-      });
+      if ("since_signup" in item && item.since_signup) {
+        details.push({
+          text: `Member since: ${item.since_signup}`,
+          style: "dim" as const,
+        });
+      }
 
       return {
         title: item.full_name,
-        subtitle: `@${item.username}`,
+        id: item.id.toString(),
         details,
       };
     },

package/src/sdk.ts

@@ -9,6 +9,7 @@ import type {
   Sdk,
   Plugin,
   ExtractContextProperties,
+  ExtractSdkProperties,
   PluginProvides,
   PluginMeta,
 } from "./types/plugin";
@@ -32,7 +33,6 @@ import { listInputFieldsPlugin } from "./plugins/listInputFields";
 import { listInputFieldChoicesPlugin } from "./plugins/listInputFieldChoices";
 import { requestPlugin } from "./plugins/request";
 import { manifestPlugin } from "./plugins/manifest";
-import { lockVersionPlugin } from "./plugins/lockVersion";
 
 // Full SDK interface with plugins applied
 // Note: ZapierSdk is now defined as ReturnType<typeof createZapierSdk> at the bottom of this file
@@ -42,12 +42,14 @@ export interface ZapierSdkOptions extends BaseSdkOptions {}
 // Create SDK that supports flat plugins - returns an SDK, not a builder
 export function createSdk<
   TCurrentSdk = {},
-  TCurrentContext = { meta: Record<string, PluginMeta> },
+  TCurrentContext extends { meta: Record<string, PluginMeta> } = {
+    meta: Record<string, PluginMeta>;
+  },
 >(
   options: ZapierSdkOptions = {},
   initialSdk: TCurrentSdk = {} as TCurrentSdk,
   initialContext: TCurrentContext = { meta: {} } as TCurrentContext,
-): Sdk<TCurrentSdk, TCurrentContext> {
+) {
   return {
     ...initialSdk,
     getContext: () => initialContext,
@@ -57,8 +59,11 @@ export function createSdk<
         TRequiresContext,
         TProvides
       >,
-      addPluginOptions: any = {},
-    ) {
+      addPluginOptions: Record<string, unknown> = {},
+    ): Sdk<
+      TCurrentSdk & ExtractSdkProperties<TProvides>,
+      TCurrentContext & NonNullable<ExtractContextProperties<TProvides>>
+    > {
       // Create SDK with getContext method for plugins to use
       const currentSdkWithContext = {
         ...initialSdk,
@@ -72,7 +77,7 @@ export function createSdk<
           ...initialContext,
           // Add the options that createSdk was called with to context
           options,
-        },
+        } as TCurrentContext & { options: ZapierSdkOptions } & TRequiresContext,
         ...addPluginOptions,
       });
 
@@ -87,7 +92,8 @@ export function createSdk<
       let newContext = {
         ...initialContext,
         ...addPluginOptions,
-        meta: (initialContext as any).meta || {},
+        meta:
+          (initialContext as { meta?: Record<string, PluginMeta> }).meta || {},
       } as TCurrentContext & NonNullable<ExtractContextProperties<TProvides>>;
 
       if (pluginContext) {
@@ -113,7 +119,10 @@ export function createSdk<
       }
 
       // Recursively create new SDK with updated properties
-      return createSdk(options, newSdk, newContext) as any;
+      return createSdk(options, newSdk, newContext) as Sdk<
+        TCurrentSdk & ExtractSdkProperties<TProvides>,
+        TCurrentContext & NonNullable<ExtractContextProperties<TProvides>>
+      >;
     },
   };
 }
@@ -125,10 +134,10 @@ export function createZapierSdkWithoutRegistry(options: ZapierSdkOptions = {}) {
       .addPlugin(apiPlugin)
 
       // Manifest plugin (provides version locking context)
+      .addPlugin(manifestPlugin)
 
       // Apps/actions/fields
       .addPlugin(listAppsPlugin)
-      .addPlugin(manifestPlugin)
       .addPlugin(getAppPlugin)
       .addPlugin(listActionsPlugin)
       .addPlugin(getActionPlugin)
@@ -138,9 +147,6 @@ export function createZapierSdkWithoutRegistry(options: ZapierSdkOptions = {}) {
       // Run action
       .addPlugin(runActionPlugin)
 
-      // Version locking
-      .addPlugin(lockVersionPlugin)
-
       // Authentications
       .addPlugin(listAuthenticationsPlugin)
       .addPlugin(getAuthenticationPlugin)