@zapier/zapier-sdk-cli 0.4.3 → 0.5.0

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