@zapier/zapier-sdk-cli 0.4.4 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @zapier/zapier-sdk-cli
 
+## 0.5.0
+
+### Minor Changes
+
+- 218a3ca: reducing 'any' usage with minimal changes to runtime
+
+### Patch Changes
+
+- Updated dependencies [218a3ca]
+  - @zapier/zapier-sdk-cli-login@0.3.2
+  - @zapier/zapier-sdk-mcp@0.1.4
+  - @zapier/zapier-sdk@0.5.2
+
 ## 0.4.4
 
 ### Patch Changes

package/dist/cli.js

@@ -268,7 +268,7 @@ var SchemaParameterResolver = class {
         break;
       }
       const newFields = fields.filter(
-        (field) => !processedFieldKeys.has(field.key)
+        (field) => !(field.key && processedFieldKeys.has(field.key))
       );
       if (newFields.length === 0) {
         break;
@@ -343,40 +343,54 @@ Optional fields:`));
     return inputs;
   }
   getNestedValue(obj, path3) {
-    return path3.reduce((current, key) => current?.[key], obj);
+    return path3.reduce(
+      (current, key) => current?.[key],
+      obj
+    );
   }
   setNestedValue(obj, path3, value) {
     const lastKey = path3[path3.length - 1];
     const parent = path3.slice(0, -1).reduce((current, key) => {
-      if (!(key in current)) {
-        current[key] = {};
+      const currentObj = current;
+      if (!(key in currentObj)) {
+        currentObj[key] = {};
       }
-      return current[key];
+      return currentObj[key];
     }, obj);
     parent[lastKey] = value;
   }
   async promptForField(field, inputs) {
+    const fieldObj = field;
     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(`\u2139 ${field.helpText}
-`) },
-      ...field.default && { default: field.default }
+      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(`\u2139 ${fieldObj.helpText}
+`);
+    }
+    if (fieldObj.default !== void 0) {
+      fieldPrompt.default = fieldObj.default;
+    }
+    if (fieldObj.choices && fieldObj.choices.length > 0) {
       fieldPrompt.type = "list";
-      fieldPrompt.choices = field.choices.map((choice) => ({
-        name: choice.label || choice.value,
-        value: choice.value
-      }));
+      fieldPrompt.choices = fieldObj.choices.map(
+        (choice) => {
+          const choiceObj = choice;
+          return {
+            name: choiceObj.label || choiceObj.value,
+            value: choiceObj.value
+          };
+        }
+      );
     }
     try {
       const answer = await inquirer.prompt([fieldPrompt]);
-      if (answer[field.key] !== void 0 && 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] !== void 0 && 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)) {
@@ -387,7 +401,8 @@ Optional fields:`));
     }
   }
   isUserCancellation(error) {
-    return error?.name === "ExitPromptError" || error?.message?.includes("User force closed") || error?.isTTYError;
+    const errorObj = error;
+    return errorObj?.name === "ExitPromptError" || errorObj?.message?.includes("User force closed") || errorObj?.isTTYError === true;
   }
 };
 
@@ -568,24 +583,27 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
         rawParams,
         sdk2
       );
-      const hasOutputFile = resolvedParams.output;
-      if (hasOutputFile) {
-        await sdk2[sdkMethodName](resolvedParams);
-        console.log(
-          chalk3.green(`\u2705 ${cliCommandName} completed successfully!`)
-        );
-        console.log(chalk3.gray(`Output written to: ${resolvedParams.output}`));
-        return;
-      }
       if (isListCommand && hasPaginationParams && !shouldUseJson && !hasUserSpecifiedMaxItems) {
-        const sdkIterator = sdk2[sdkMethodName](resolvedParams);
+        const sdkObj = sdk2;
+        const sdkIterator = await sdkObj[sdkMethodName](resolvedParams);
         await handlePaginatedListWithAsyncIteration(
           sdkMethodName,
           sdkIterator,
           schema
         );
       } else {
-        const result = await sdk2[sdkMethodName](resolvedParams);
+        const hasOutputFile = resolvedParams.output;
+        if (hasOutputFile) {
+          const sdkObj2 = sdk2;
+          await sdkObj2[sdkMethodName](resolvedParams);
+          console.log(
+            chalk3.green(`\u2705 ${cliCommandName} completed successfully!`)
+          );
+          console.log(chalk3.gray(`Output written to: ${hasOutputFile}`));
+          return;
+        }
+        const sdkObj = sdk2;
+        const result = await sdkObj[sdkMethodName](resolvedParams);
         const items = result?.data ? result.data : result;
         if (shouldUseJson) {
           console.log(JSON.stringify(items, null, 2));
@@ -608,8 +626,13 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
           const validationErrors = JSON.parse(error.message);
           console.error(chalk3.red("\u274C Validation Error:"));
           validationErrors.forEach((err) => {
-            const field = err.path?.join(".") || "unknown";
-            console.error(chalk3.yellow(`  \u2022 ${field}: ${err.message}`));
+            const errorObj = err;
+            const field = errorObj?.path?.join(".") || "unknown";
+            console.error(
+              chalk3.yellow(
+                `  \u2022 ${field}: ${errorObj?.message || "Unknown error"}`
+              )
+            );
           });
           console.error(
             "\n" + chalk3.dim(`Use --help to see available options`)
@@ -658,10 +681,18 @@ function addCommand(program2, commandName, config) {
         command.option(flags.join(", "), param.description);
       } else if (param.type === "array") {
         const flagSignature = flags.join(", ") + ` <values...>`;
-        command.option(flagSignature, param.description, param.default);
+        command.option(
+          flagSignature,
+          param.description,
+          param.default
+        );
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
-        command.option(flagSignature, param.description, param.default);
+        command.option(
+          flagSignature,
+          param.description || "",
+          param.default
+        );
       }
     }
   });
@@ -826,10 +857,11 @@ function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxIt
 }
 function formatItemsGeneric2(items) {
   items.forEach((item, index) => {
-    const name = item.title || item.name || item.key || item.id || "Item";
-    console.log(`${chalk3.gray(`${index + 1}.`)} ${chalk3.cyan(name)}`);
-    if (item.description) {
-      console.log(`   ${chalk3.dim(item.description)}`);
+    const itemObj = item;
+    const name = itemObj?.name || itemObj?.key || itemObj?.id || "Item";
+    console.log(`${chalk3.gray(`${index + 1}.`)} ${chalk3.cyan(String(name))}`);
+    if (itemObj?.description) {
+      console.log(`   ${chalk3.dim(String(itemObj.description))}`);
     }
     console.log();
   });
@@ -1556,7 +1588,11 @@ function createGenerateTypesCommand() {
         command.option(flags.join(", "), param.description);
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
-        command.option(flagSignature, param.description, param.default);
+        command.option(
+          flagSignature,
+          param.description || "",
+          param.default
+        );
       }
     }
   });
@@ -1577,16 +1613,24 @@ function createGenerateTypesCommand() {
         rawParams,
         sdk2
       );
+      const params = resolvedParams;
       console.log(
         chalk5.blue(
-          `\u{1F527} Generating TypeScript types for ${resolvedParams.appKey}...`
+          `\u{1F527} Generating TypeScript types for ${params.appKey}...`
         )
       );
-      const result = await generateTypes({ ...resolvedParams, sdk: sdk2 });
+      const generateTypesParams = {
+        appKey: params.appKey,
+        debug: params.debug ?? false,
+        authenticationId: params.authenticationId,
+        output: params.output,
+        sdk: sdk2
+      };
+      const result = await generateTypes(generateTypesParams);
       if (options.json) {
         console.log(JSON.stringify({ result }, null, 2));
       } else {
-        const output = resolvedParams.output || `./types/${resolvedParams.appKey}.d.ts`;
+        const output = params.output || `./types/${params.appKey}.d.ts`;
         console.log(chalk5.green("\u2705 TypeScript types generated successfully!"));
         console.log(chalk5.gray(`Output written to: ${output}`));
       }
@@ -1717,7 +1761,11 @@ function createBundleCodeCommand() {
         command.option(flags.join(", "), param.description);
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
-        command.option(flagSignature, param.description, param.default);
+        command.option(
+          flagSignature,
+          param.description || "",
+          param.default
+        );
       }
     }
   });
@@ -1735,7 +1783,9 @@ function createBundleCodeCommand() {
         throw new Error("Input file path is required");
       }
       console.log(chalk6.blue(`\u{1F4E6} Bundling ${rawParams.input}...`));
-      const result = await bundleCode(rawParams);
+      const result = await bundleCode(
+        rawParams
+      );
       if (options.json) {
         console.log(JSON.stringify({ result }, null, 2));
       } else if (rawParams.output && !rawParams.string) {

package/dist/src/commands/bundle-code/cli.js

@@ -32,7 +32,7 @@ export function createBundleCodeCommand() {
             }
             else {
                 const flagSignature = flags.join(", ") + ` <${param.type}>`;
-                command.option(flagSignature, param.description, param.default);
+                command.option(flagSignature, param.description || "", param.default);
             }
         }
     });

package/dist/src/commands/generate-types/cli.js

@@ -34,7 +34,7 @@ export function createGenerateTypesCommand() {
             }
             else {
                 const flagSignature = flags.join(", ") + ` <${param.type}>`;
-                command.option(flagSignature, param.description, param.default);
+                command.option(flagSignature, param.description || "", param.default);
             }
         }
     });
@@ -52,14 +52,23 @@ export function createGenerateTypesCommand() {
             // Resolve missing parameters interactively using schema metadata
             const resolver = new SchemaParameterResolver();
             const resolvedParams = await resolver.resolveParameters(GenerateTypesSchema, rawParams, sdk);
-            console.log(chalk.blue(`🔧 Generating TypeScript types for ${resolvedParams.appKey}...`));
+            const params = resolvedParams;
+            console.log(chalk.blue(`🔧 Generating TypeScript types for ${params.appKey}...`));
             // Call our implementation
-            const result = await generateTypes({ ...resolvedParams, sdk });
+            const generateTypesParams = {
+                appKey: params.appKey,
+                debug: params.debug ?? false,
+                authenticationId: params.authenticationId,
+                output: params.output,
+                sdk,
+            };
+            const result = await generateTypes(generateTypesParams);
             if (options.json) {
                 console.log(JSON.stringify({ result }, null, 2));
             }
             else {
-                const output = resolvedParams.output || `./types/${resolvedParams.appKey}.d.ts`;
+                const output = params.output ||
+                    `./types/${params.appKey}.d.ts`;
                 console.log(chalk.green("✅ TypeScript types generated successfully!"));
                 console.log(chalk.gray(`Output written to: ${output}`));
             }

package/dist/src/utils/api/client.d.ts

@@ -1,14 +1,14 @@
-export interface ApiResponse<T = any> {
+export interface ApiResponse<T = unknown> {
     data: T;
     status: number;
 }
 export declare const createApiClient: () => {
-    post: <T = any>(url: string, data: any, options?: {
+    post: <T = unknown>(url: string, data: Record<string, string>, options?: {
         headers?: Record<string, string>;
     }) => Promise<ApiResponse<T>>;
 };
 declare const api: {
-    post: <T = any>(url: string, data: any, options?: {
+    post: <T = unknown>(url: string, data: Record<string, string>, options?: {
         headers?: Record<string, string>;
     }) => Promise<ApiResponse<T>>;
 };

package/dist/src/utils/cli-generator-utils.d.ts

@@ -4,10 +4,10 @@ export interface CliParameter {
     type: "string" | "number" | "boolean" | "array";
     required: boolean;
     description?: string;
-    default?: any;
+    default?: unknown;
     choices?: string[];
     hasResolver?: boolean;
     isPositional?: boolean;
 }
 export declare function analyzeZodSchema(schema: z.ZodSchema): CliParameter[];
-export declare function convertCliArgsToSdkParams(parameters: CliParameter[], positionalArgs: any[], options: Record<string, any>): Record<string, any>;
+export declare function convertCliArgsToSdkParams(parameters: CliParameter[], positionalArgs: unknown[], options: Record<string, unknown>): Record<string, unknown>;

package/dist/src/utils/cli-generator.js

@@ -13,7 +13,9 @@ function formatJsonOutput(data) {
     if (data &&
         typeof data === "object" &&
         !Array.isArray(data) &&
-        (data.success !== undefined || data.id || data.status)) {
+        (data.success !== undefined ||
+            data.id ||
+            data.status)) {
         console.log(chalk.green("✅ Action completed successfully!\n"));
     }
     // Use util.inspect for colored output
@@ -140,28 +142,33 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
             // Resolve missing parameters interactively using schema metadata
             const resolver = new SchemaParameterResolver();
             const resolvedParams = await resolver.resolveParameters(schema, rawParams, sdk);
-            // Special handling for commands that write to files
-            const hasOutputFile = resolvedParams.output;
-            if (hasOutputFile) {
-                // Call the SDK method for file output commands
-                await sdk[sdkMethodName](resolvedParams);
-                console.log(chalk.green(`✅ ${cliCommandName} completed successfully!`));
-                console.log(chalk.gray(`Output written to: ${resolvedParams.output}`));
-                return;
-            }
             // Handle paginated list commands with async iteration
             if (isListCommand &&
                 hasPaginationParams &&
                 !shouldUseJson &&
                 !hasUserSpecifiedMaxItems) {
                 // Get the async iterator directly from the SDK method call
-                const sdkIterator = sdk[sdkMethodName](resolvedParams);
+                const sdkObj = sdk;
+                const sdkIterator = await sdkObj[sdkMethodName](resolvedParams);
                 await handlePaginatedListWithAsyncIteration(sdkMethodName, sdkIterator, schema);
             }
             else {
+                // Special handling for commands that write to files
+                const hasOutputFile = resolvedParams.output;
+                if (hasOutputFile) {
+                    // Call the SDK method for file output commands
+                    const sdkObj = sdk;
+                    await sdkObj[sdkMethodName](resolvedParams);
+                    console.log(chalk.green(`✅ ${cliCommandName} completed successfully!`));
+                    console.log(chalk.gray(`Output written to: ${hasOutputFile}`));
+                    return;
+                }
                 // Call the SDK method and handle non-paginated results
-                const result = await sdk[sdkMethodName](resolvedParams);
-                const items = result?.data ? result.data : result;
+                const sdkObj = sdk;
+                const result = await sdkObj[sdkMethodName](resolvedParams);
+                const items = result?.data
+                    ? result.data
+                    : result;
                 if (shouldUseJson) {
                     console.log(JSON.stringify(items, null, 2));
                 }
@@ -180,8 +187,9 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
                     const validationErrors = JSON.parse(error.message);
                     console.error(chalk.red("❌ Validation Error:"));
                     validationErrors.forEach((err) => {
-                        const field = err.path?.join(".") || "unknown";
-                        console.error(chalk.yellow(`  • ${field}: ${err.message}`));
+                        const errorObj = err;
+                        const field = errorObj?.path?.join(".") || "unknown";
+                        console.error(chalk.yellow(`  • ${field}: ${errorObj?.message || "Unknown error"}`));
                     });
                     console.error("\n" + chalk.dim(`Use --help to see available options`));
                 }
@@ -239,7 +247,7 @@ function addCommand(program, commandName, config) {
             }
             else {
                 const flagSignature = flags.join(", ") + ` <${param.type}>`;
-                command.option(flagSignature, param.description, param.default);
+                command.option(flagSignature, param.description || "", param.default);
             }
         }
     });
@@ -415,10 +423,11 @@ function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxIt
 function formatItemsGeneric(items) {
     // Fallback formatting for items without schema metadata
     items.forEach((item, index) => {
-        const name = item.title || item.name || item.key || item.id || "Item";
-        console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(name)}`);
-        if (item.description) {
-            console.log(`   ${chalk.dim(item.description)}`);
+        const itemObj = item;
+        const name = itemObj?.name || itemObj?.key || itemObj?.id || "Item";
+        console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(String(name))}`);
+        if (itemObj?.description) {
+            console.log(`   ${chalk.dim(String(itemObj.description))}`);
         }
         console.log();
     });

package/dist/src/utils/log.d.ts

@@ -1,7 +1,7 @@
 declare const log: {
-    info: (message: string, ...args: any[]) => void;
-    error: (message: string, ...args: any[]) => void;
-    success: (message: string, ...args: any[]) => void;
-    warn: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    success: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
 };
 export default log;

package/dist/src/utils/parameter-resolver.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { ZapierSdk } from "@zapier/zapier-sdk";
 export declare class SchemaParameterResolver {
-    resolveParameters(schema: z.ZodSchema, providedParams: any, sdk: ZapierSdk): Promise<any>;
+    resolveParameters(schema: z.ZodSchema, providedParams: unknown, sdk: ZapierSdk): Promise<unknown>;
     private extractParametersFromSchema;
     private analyzeFieldSchema;
     private createResolvableParameter;

package/dist/src/utils/parameter-resolver.js

@@ -55,7 +55,7 @@ export class SchemaParameterResolver {
             }
             return parseResult.data;
         }
-        // 2. Resolve functionally required parameters and their dependencies first
+        // 2. Resolve functionally required parameters first
         const resolvedParams = { ...providedParams };
         const context = {
             sdk,
@@ -274,7 +274,8 @@ export class SchemaParameterResolver {
                 break;
             }
             // Find new fields that we haven't processed yet
-            const newFields = fields.filter((field) => !processedFieldKeys.has(field.key));
+            const newFields = fields.filter((field) => !(field.key &&
+                processedFieldKeys.has(field.key)));
             if (newFields.length === 0) {
                 // No new fields, we're done
                 break;
@@ -340,35 +341,44 @@ export class SchemaParameterResolver {
     setNestedValue(obj, path, value) {
         const lastKey = path[path.length - 1];
         const parent = path.slice(0, -1).reduce((current, key) => {
-            if (!(key in current)) {
-                current[key] = {};
+            const currentObj = current;
+            if (!(key in currentObj)) {
+                currentObj[key] = {};
             }
-            return current[key];
+            return currentObj[key];
         }, obj);
         parent[lastKey] = value;
     }
     async promptForField(field, inputs) {
+        const fieldObj = field;
         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 }),
+            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.choices = field.choices.map((choice) => ({
-                name: choice.label || choice.value,
-                value: choice.value,
-            }));
+            fieldPrompt.choices = fieldObj.choices.map((choice) => {
+                const choiceObj = choice;
+                return {
+                    name: choiceObj.label || choiceObj.value,
+                    value: choiceObj.value,
+                };
+            });
         }
         try {
             const answer = await inquirer.prompt([fieldPrompt]);
-            if (answer[field.key] !== undefined && answer[field.key] !== "") {
-                inputs[field.key] = answer[field.key];
+            if (answer[fieldObj.key] !== undefined && answer[fieldObj.key] !== "") {
+                inputs[fieldObj.key] = answer[fieldObj.key];
             }
-            else if (field.required) {
-                throw new Error(`Required field ${field.key} cannot be empty`);
+            else if (fieldObj.required) {
+                throw new Error(`Required field ${fieldObj.key} cannot be empty`);
             }
         }
         catch (error) {
@@ -380,8 +390,9 @@ export class SchemaParameterResolver {
         }
     }
     isUserCancellation(error) {
-        return (error?.name === "ExitPromptError" ||
-            error?.message?.includes("User force closed") ||
-            error?.isTTYError);
+        const errorObj = error;
+        return (errorObj?.name === "ExitPromptError" ||
+            errorObj?.message?.includes("User force closed") ||
+            errorObj?.isTTYError === true);
     }
 }