@zapier/zapier-sdk-cli 0.4.4 → 0.6.0

package/src/utils/log.ts

@@ -1,16 +1,16 @@
 import chalk from "chalk";
 
 const log = {
-  info: (message: string, ...args: any[]) => {
+  info: (message: string, ...args: unknown[]) => {
     console.log(chalk.blue("ℹ"), message, ...args);
   },
-  error: (message: string, ...args: any[]) => {
+  error: (message: string, ...args: unknown[]) => {
     console.error(chalk.red("✖"), message, ...args);
   },
-  success: (message: string, ...args: any[]) => {
+  success: (message: string, ...args: unknown[]) => {
     console.log(chalk.green("✓"), message, ...args);
   },
-  warn: (message: string, ...args: any[]) => {
+  warn: (message: string, ...args: unknown[]) => {
     console.log(chalk.yellow("⚠"), message, ...args);
   },
 };

package/src/utils/parameter-resolver.ts

@@ -22,8 +22,8 @@ interface ResolvableParameter {
 
 interface ResolverContext {
   sdk: ZapierSdk;
-  currentParams: any;
-  resolvedParams: any;
+  currentParams: Record<string, unknown>;
+  resolvedParams: Record<string, unknown>;
 }
 
 // ============================================================================
@@ -33,9 +33,9 @@ interface ResolverContext {
 export class SchemaParameterResolver {
   async resolveParameters(
     schema: z.ZodSchema,
-    providedParams: any,
+    providedParams: unknown,
     sdk: ZapierSdk,
-  ): Promise<any> {
+  ): Promise<unknown> {
     // 1. Try to parse with current parameters
     const parseResult = schema.safeParse(providedParams);
 
@@ -102,11 +102,11 @@ export class SchemaParameterResolver {
       return parseResult.data;
     }
 
-    // 2. Resolve functionally required parameters and their dependencies first
-    const resolvedParams = { ...providedParams };
+    // 2. Resolve functionally required parameters first
+    const resolvedParams = { ...(providedParams as Record<string, unknown>) };
     const context: ResolverContext = {
       sdk,
-      currentParams: providedParams,
+      currentParams: providedParams as Record<string, unknown>,
       resolvedParams,
     };
 
@@ -306,7 +306,7 @@ export class SchemaParameterResolver {
   private async resolveParameter(
     param: ResolvableParameter,
     context: ResolverContext,
-  ): Promise<any> {
+  ): Promise<unknown> {
     const resolver = getResolver(param.name);
     if (!resolver) {
       throw new Error(`No resolver found for parameter: ${param.name}`);
@@ -314,39 +314,55 @@ export class SchemaParameterResolver {
 
     console.log(chalk.blue(`\n🔍 Resolving ${param.name}...`));
 
-    if (resolver.type === "static") {
+    const typedResolver = resolver as {
+      type: string;
+      inputType?: string;
+      placeholder?: string;
+      fetch?: Function;
+      prompt?: Function;
+    };
+
+    if (typedResolver.type === "static") {
       // Static resolver - just prompt for input
       const promptConfig = {
-        type: resolver.inputType === "password" ? "password" : "input",
+        type: typedResolver.inputType === "password" ? "password" : "input",
         name: param.name,
         message: `Enter ${param.name}:`,
-        ...(resolver.placeholder && { default: resolver.placeholder }),
+        ...(typedResolver.placeholder && {
+          default: typedResolver.placeholder,
+        }),
       };
 
       const answers = await inquirer.prompt([promptConfig as any]);
       return answers[param.name];
-    } else if (resolver.type === "dynamic") {
+    } else if (typedResolver.type === "dynamic") {
       // Dynamic resolver - fetch options and prompt for selection
       try {
         // Only show "Fetching..." for required parameters that typically have many options
         if (param.isRequired && param.name !== "authenticationId") {
           console.log(chalk.gray(`Fetching options for ${param.name}...`));
         }
-        const items = await resolver.fetch(context.sdk, context.resolvedParams);
+        const items = await typedResolver.fetch!(
+          context.sdk,
+          context.resolvedParams,
+        );
 
         // Let the resolver's prompt handle empty lists (e.g., authenticationId can show "skip authentication")
         const safeItems = items || [];
-        const promptConfig = resolver.prompt(safeItems, context.resolvedParams);
+        const promptConfig = typedResolver.prompt!(
+          safeItems,
+          context.resolvedParams,
+        );
         const answers = await inquirer.prompt([promptConfig as any]);
         return answers[param.name];
       } catch (error) {
         // Let the main CLI error handler display user-friendly errors
         throw error;
       }
-    } else if ((resolver as any).type === "fields") {
+    } else if (typedResolver.type === "fields") {
       // Fields resolver - fetch field definitions and prompt for each input with recursive field resolution
       return await this.resolveFieldsRecursively(
-        resolver as any,
+        resolver as unknown,
         context,
         param,
       );
@@ -356,11 +372,12 @@ export class SchemaParameterResolver {
   }
 
   private async resolveFieldsRecursively(
-    resolver: any,
+    resolver: unknown,
     context: ResolverContext,
     param: ResolvableParameter,
-  ): Promise<Record<string, any>> {
-    const inputs: Record<string, any> = {};
+  ): Promise<Record<string, unknown>> {
+    const typedResolver = resolver as { fetch: Function };
+    const inputs: Record<string, unknown> = {};
     let processedFieldKeys = new Set<string>();
     let iteration = 0;
     const maxIterations = 5; // Prevent infinite loops
@@ -383,7 +400,7 @@ export class SchemaParameterResolver {
         ),
       );
 
-      const fields = await resolver.fetch(
+      const fields = await typedResolver.fetch(
         updatedContext.sdk,
         updatedContext.resolvedParams,
       );
@@ -399,7 +416,11 @@ export class SchemaParameterResolver {
 
       // Find new fields that we haven't processed yet
       const newFields = fields.filter(
-        (field: any) => !processedFieldKeys.has(field.key),
+        (field: unknown) =>
+          !(
+            (field as { key: string }).key &&
+            processedFieldKeys.has((field as { key: string }).key)
+          ),
       );
 
       if (newFields.length === 0) {
@@ -409,10 +430,10 @@ export class SchemaParameterResolver {
 
       // Separate new required and optional fields
       const newRequiredFields = newFields.filter(
-        (field: any) => field.required,
+        (field: unknown) => (field as { required: boolean }).required,
       );
       const newOptionalFields = newFields.filter(
-        (field: any) => !field.required,
+        (field: unknown) => !(field as { required: boolean }).required,
       );
 
       // Prompt for new required fields
@@ -424,7 +445,7 @@ export class SchemaParameterResolver {
         );
         for (const field of newRequiredFields) {
           await this.promptForField(field, inputs);
-          processedFieldKeys.add(field.key);
+          processedFieldKeys.add((field as { key: string }).key);
         }
       }
 
@@ -458,12 +479,12 @@ export class SchemaParameterResolver {
           console.log(chalk.cyan(`\nOptional fields:`));
           for (const field of newOptionalFields) {
             await this.promptForField(field, inputs);
-            processedFieldKeys.add(field.key);
+            processedFieldKeys.add((field as { key: string }).key);
           }
         } else {
           // Mark these fields as processed even if skipped to avoid re-asking
-          newOptionalFields.forEach((field: any) =>
-            processedFieldKeys.add(field.key),
+          newOptionalFields.forEach((field: unknown) =>
+            processedFieldKeys.add((field as { key: string }).key),
           );
         }
       }
@@ -488,48 +509,73 @@ export class SchemaParameterResolver {
     return inputs;
   }
 
-  private getNestedValue(obj: any, path: string[]): any {
-    return path.reduce((current, key) => current?.[key], obj);
+  private getNestedValue(obj: unknown, path: string[]): unknown {
+    return path.reduce(
+      (current, key) => (current as Record<string, unknown>)?.[key],
+      obj,
+    );
   }
 
-  private setNestedValue(obj: any, path: string[], value: any): void {
+  private setNestedValue(obj: unknown, path: string[], value: unknown): void {
     const lastKey = path[path.length - 1];
     const parent = path.slice(0, -1).reduce((current, key) => {
-      if (!(key in current)) {
-        current[key] = {};
+      const currentObj = current as Record<string, unknown>;
+      if (!(key in currentObj)) {
+        currentObj[key] = {};
       }
-      return current[key];
-    }, obj);
+      return currentObj[key];
+    }, obj) as Record<string, unknown>;
     parent[lastKey] = value;
   }
 
   private async promptForField(
-    field: any,
-    inputs: Record<string, any>,
+    field: unknown,
+    inputs: Record<string, unknown>,
   ): Promise<void> {
-    const fieldPrompt = {
-      type: field.type === "boolean" ? "confirm" : "input",
-      name: field.key,
-      message: `${field.label || field.key}${field.required ? " (required)" : " (optional)"}:`,
-      ...(field.helpText && { prefix: chalk.gray(`ℹ ${field.helpText}\n`) }),
-      ...(field.default && { default: field.default }),
+    const fieldObj = field as {
+      type?: string;
+      key: string;
+      label?: string;
+      required?: boolean;
+      helpText?: string;
+      default?: unknown;
+      choices?: Array<{ label?: string; value: unknown }>;
+    };
+
+    const fieldPrompt: Record<string, unknown> = {
+      type: fieldObj.type === "boolean" ? "confirm" : "input",
+      name: fieldObj.key,
+      message: `${fieldObj.label || fieldObj.key}${fieldObj.required ? " (required)" : " (optional)"}:`,
     };
 
-    if (field.choices && field.choices.length > 0) {
+    if (fieldObj.helpText) {
+      fieldPrompt.prefix = chalk.gray(`ℹ ${fieldObj.helpText}\n`);
+    }
+
+    if (fieldObj.default !== undefined) {
+      fieldPrompt.default = fieldObj.default;
+    }
+
+    if (fieldObj.choices && fieldObj.choices.length > 0) {
       fieldPrompt.type = "list";
-      (fieldPrompt as any).choices = field.choices.map((choice: any) => ({
-        name: choice.label || choice.value,
-        value: choice.value,
-      }));
+      (fieldPrompt as { choices: unknown[] }).choices = fieldObj.choices.map(
+        (choice: unknown) => {
+          const choiceObj = choice as { label?: unknown; value: unknown };
+          return {
+            name: choiceObj.label || choiceObj.value,
+            value: choiceObj.value,
+          };
+        },
+      );
     }
 
     try {
       const answer = await inquirer.prompt([fieldPrompt as any]);
 
-      if (answer[field.key] !== undefined && answer[field.key] !== "") {
-        inputs[field.key] = answer[field.key];
-      } else if (field.required) {
-        throw new Error(`Required field ${field.key} cannot be empty`);
+      if (answer[fieldObj.key] !== undefined && answer[fieldObj.key] !== "") {
+        inputs[fieldObj.key] = answer[fieldObj.key];
+      } else if (fieldObj.required) {
+        throw new Error(`Required field ${fieldObj.key} cannot be empty`);
       }
     } catch (error) {
       if (this.isUserCancellation(error)) {
@@ -540,11 +586,16 @@ export class SchemaParameterResolver {
     }
   }
 
-  private isUserCancellation(error: any): boolean {
+  private isUserCancellation(error: unknown): boolean {
+    const errorObj = error as {
+      name?: string;
+      message?: string;
+      isTTYError?: boolean;
+    };
     return (
-      error?.name === "ExitPromptError" ||
-      error?.message?.includes("User force closed") ||
-      error?.isTTYError
+      errorObj?.name === "ExitPromptError" ||
+      errorObj?.message?.includes("User force closed") ||
+      errorObj?.isTTYError === true
     );
   }
 }

package/src/utils/schema-formatter.ts

@@ -13,15 +13,16 @@ interface FormattedItem {
 }
 
 interface FormatMetadata {
-  format: (item: any) => FormattedItem;
+  format: (item: unknown) => FormattedItem;
 }
 
-function getFormatMetadata(schema: any): FormatMetadata | undefined {
-  return schema?._def?.formatMeta;
+function getFormatMetadata(schema: unknown): FormatMetadata | undefined {
+  return (schema as { _def?: { formatMeta?: FormatMetadata } })?._def
+    ?.formatMeta;
 }
 
-function getOutputSchema(schema: any): any {
-  return schema?._def?.outputSchema;
+function getOutputSchema(schema: unknown): unknown {
+  return (schema as { _def?: { outputSchema?: unknown } })?._def?.outputSchema;
 }
 
 // ============================================================================
@@ -30,7 +31,7 @@ function getOutputSchema(schema: any): any {
 
 export function formatItemsFromSchema(
   inputSchema: z.ZodType,
-  items: any[],
+  items: unknown[],
 ): void {
   // Get the output schema and its format metadata
   const outputSchema = getOutputSchema(inputSchema);
@@ -54,7 +55,7 @@ export function formatItemsFromSchema(
 }
 
 function formatSingleItem(
-  item: any,
+  item: unknown,
   index: number,
   formatMeta: FormatMetadata,
 ): void {
@@ -93,13 +94,21 @@ function applyStyle(value: string, style: string): string {
   }
 }
 
-function formatItemsGeneric(items: any[]): void {
+function formatItemsGeneric(items: unknown[]): void {
   // Fallback formatting for items without schema metadata
   items.forEach((item, index) => {
-    const name = item.title || item.name || item.key || item.id || "Item";
+    const itemObj = item as {
+      title?: string;
+      name?: string;
+      key?: string;
+      id?: string;
+      description?: string;
+    };
+    const name =
+      itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item";
     console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(name)}`);
-    if (item.description) {
-      console.log(`   ${chalk.dim(item.description)}`);
+    if (itemObj.description) {
+      console.log(`   ${chalk.dim(itemObj.description)}`);
     }
     console.log();
   });