@zapier/zapier-sdk-cli 0.4.3 → 0.5.0

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,
     };
 
@@ -356,7 +356,10 @@ export class SchemaParameterResolver {
   }
 
   private async resolveFieldsRecursively(
-    resolver: any,
+    resolver: {
+      fetch: (sdk: unknown, params: unknown) => Promise<unknown[]>;
+      prompt: (items: unknown[], params: unknown) => unknown;
+    },
     context: ResolverContext,
     param: ResolvableParameter,
   ): Promise<Record<string, any>> {
@@ -399,7 +402,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 +416,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 +431,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 +465,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 +495,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,
+    field: unknown,
     inputs: Record<string, any>,
   ): 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 }>;
     };
 
-    if (field.choices && field.choices.length > 0) {
+    const fieldPrompt: Record<string, unknown> = {
+      type: fieldObj.type === "boolean" ? "confirm" : "input",
+      name: fieldObj.key,
+      message: `${fieldObj.label || fieldObj.key}${fieldObj.required ? " (required)" : " (optional)"}:`,
+    };
+
+    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 +572,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
     );
   }
 }