@zapier/zapier-sdk 0.9.0 → 0.11.0

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,70 @@
+import type { DynamicResolver } from "../utils/schema-utils";
+import type { InputFieldItem } from "../schemas/Field";
+import type { ActionTypeProperty } from "../types/properties";
+import type {
+  RootFieldItem,
+  InfoFieldItem,
+  FieldsetItem,
+} from "../types/domain";
+
+/**
+ * Helper function to flatten fieldsets into a flat array of input fields.
+ * Used to extract all input fields from nested fieldset structure for field selection.
+ */
+function flattenRootFieldset(rootFieldset: RootFieldItem[]): InputFieldItem[] {
+  const result: InputFieldItem[] = [];
+
+  function processItem(item: InputFieldItem | InfoFieldItem | FieldsetItem) {
+    if (item.type === "input_field") {
+      result.push(item);
+    } else if (item.type === "fieldset") {
+      // Recursively process fields in the fieldset
+      for (const field of item.fields) {
+        processItem(field);
+      }
+    }
+    // Skip info fields as they're not input fields
+  }
+
+  for (const item of rootFieldset) {
+    processItem(item);
+  }
+
+  return result;
+}
+
+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
+    });
+    // Flatten the fieldset structure for field selection
+    return flattenRootFieldset(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,46 @@
-import type { ZapierSdk } from "../types/sdk";
+import type { ActionTypeProperty } from "../types/properties";
+import type { RootFieldItem } from "../types/domain";
 
-export interface InputsResolver {
+// Helper function to recursively make all input fields optional while preserving structure
+function makeFieldsOptional(fields: RootFieldItem[]): RootFieldItem[] {
+  return fields.map((field) => {
+    if (field.type === "input_field") {
+      return {
+        ...field,
+        is_required: false,
+      };
+    } else if (field.type === "fieldset") {
+      return {
+        ...field,
+        fields: makeFieldsOptional(field.fields),
+      };
+    } else {
+      // Info fields remain unchanged
+      return field;
+    }
+  });
+}
+
+// Custom resolver type for fieldsets - returns the nested structure
+type InputsResolver = {
   type: "fields";
   depends: readonly string[];
   fetch: (
-    sdk: ZapierSdk,
-    resolvedParams: Record<string, any>,
-  ) => Promise<any[]>;
-}
+    sdk: any,
+    resolvedParams: {
+      appKey: string;
+      actionKey: string;
+      actionType: ActionTypeProperty;
+      authenticationId: number;
+      inputs?: Record<string, unknown>;
+    },
+  ) => Promise<RootFieldItem[]>;
+};
 
 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 +51,19 @@ 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 nested structure with all fields marked as optional.
+    return makeFieldsOptional(fieldsResponse.data);
+  },
+};

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,31 @@
 import { z } from "zod";
 import { withFormatter } from "../utils/schema-utils";
-import { NeedSchema } from "../api/schemas";
+
+// ============================================================================
+// Base Field Schema
+// ============================================================================
+
+export const BaseFieldItemSchema = z.object({
+  type: z.string(), // "input_field", "info_field", or "fieldset"
+  key: z.string(), // From need.key
+});
 
 // ============================================================================
 // 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'
+  BaseFieldItemSchema.extend({
+    type: z.literal("input_field"),
     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 +34,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 +43,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 +67,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,44 +80,90 @@ 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,
       };
     },
   },
 );
 
+// ============================================================================
+// Info Field Item Schema (for help text and copy fields)
+// ============================================================================
+
+export const InfoFieldItemSchema = withFormatter(
+  BaseFieldItemSchema.extend({
+    type: z.literal("info_field"),
+    description: z.string(), // From need.help_text
+    title: z.string().optional(), // Optional title
+  }),
+  {
+    format: (item) => ({
+      title: item.title || "Info",
+      key: item.key,
+      description: item.description,
+      details: [{ text: item.description, style: "normal" as const }],
+    }),
+  },
+);
+
+// ============================================================================
+// Fieldset Schema (for grouping fields)
+// ============================================================================
+
+// Forward reference for recursive type
+type FieldsetItemType =
+  | z.infer<typeof InputFieldItemSchema>
+  | z.infer<typeof InfoFieldItemSchema>
+  | FieldsetItem;
+
+export interface FieldsetItem {
+  type: "fieldset";
+  key: string;
+  title: string;
+  fields: FieldsetItemType[];
+}
+
+export const FieldsetItemSchema: z.ZodType<FieldsetItem> =
+  BaseFieldItemSchema.extend({
+    type: z.literal("fieldset"),
+    title: z.string(),
+    fields: z.lazy(() =>
+      z.array(
+        z.union([
+          InputFieldItemSchema,
+          InfoFieldItemSchema,
+          FieldsetItemSchema,
+        ]),
+      ),
+    ),
+  });
+
+// ============================================================================
+// Root Field Item Schema (union of all possible field types)
+// ============================================================================
+
+export const RootFieldItemSchema = z.union([
+  InputFieldItemSchema,
+  InfoFieldItemSchema,
+  FieldsetItemSchema,
+]);
+
 // ============================================================================
 // Type Exports
 // ============================================================================
 
 export type InputFieldItem = z.infer<typeof InputFieldItemSchema>;
-
-// Legacy alias for backward compatibility
-export type FieldItem = InputFieldItem;
+export type InfoFieldItem = z.infer<typeof InfoFieldItemSchema>;
+export type RootFieldItem = z.infer<typeof RootFieldItemSchema>;