@zapier/zapier-sdk-cli 0.30.0 → 0.31.1

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

@@ -105,8 +105,8 @@ function analyzeZodField(name, schema, functionInfo) {
         choices = baseSchema.options;
     }
     else if (baseSchema instanceof z.ZodRecord) {
-        // Handle Record<string, any> as JSON string input
-        paramType = "string";
+        // Handle Record<string, any> - user passes JSON string, we parse to object
+        paramType = "object";
     }
     // Check if this parameter has a resolver
     let paramHasResolver = false;
@@ -441,8 +441,14 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
         parameters,
         handler,
         hidden: functionInfo.categories?.includes("deprecated") ?? false,
+        aliases: functionInfo.aliases,
     };
 }
+// Collect function for repeatable options (e.g., -d foo -d bar → ['foo', 'bar'])
+function collect(value, previous = []) {
+    previous.push(value);
+    return previous;
+}
 function addCommand(program, commandName, config) {
     const command = program
         .command(commandName, { hidden: config.hidden ?? false })
@@ -465,10 +471,10 @@ function addCommand(program, commandName, config) {
             command.argument(`<${kebabName}...>`, param.description || `${kebabName} parameter`);
         }
         else if (param.required && param.type === "array") {
-            // Subsequent required array parameters become required flags
+            // Subsequent required array parameters become required flags (repeatable)
             const flags = [`--${kebabName}`];
-            const flagSignature = flags.join(", ") + ` <values...>`;
-            command.requiredOption(flagSignature, param.description || `${kebabName} parameter (required)`);
+            const flagSignature = flags.join(", ") + ` <value>`;
+            command.requiredOption(flagSignature, param.description || `${kebabName} parameter (required, repeatable)`, collect, []);
         }
         else if (param.required) {
             // Required parameters without resolvers become required positional arguments
@@ -480,14 +486,20 @@ function addCommand(program, commandName, config) {
         }
         else {
             // Optional parameters become flags (whether they have resolvers or not)
-            const flags = [`--${kebabName}`];
+            const flags = [];
+            // Add short alias if defined (single-letter aliases only)
+            const alias = config.aliases?.[param.name];
+            if (alias && alias.length === 1) {
+                flags.push(`-${alias}`);
+            }
+            flags.push(`--${kebabName}`);
             if (param.type === "boolean") {
                 command.option(flags.join(", "), param.description);
             }
             else if (param.type === "array") {
-                // For arrays, use variadic syntax to collect multiple values
-                const flagSignature = flags.join(", ") + ` <values...>`;
-                command.option(flagSignature, param.description, param.default);
+                // For arrays, use collect pattern for repeatable flags (e.g., -d foo -d bar)
+                const flagSignature = flags.join(", ") + ` <value>`;
+                command.option(flagSignature, param.description || "", collect, []);
             }
             else {
                 const flagSignature = flags.join(", ") + ` <${param.type}>`;
@@ -495,8 +507,11 @@ function addCommand(program, commandName, config) {
             }
         }
     });
-    // Add formatting options for all commands
-    command.option("--json", "Output raw JSON instead of formatted results");
+    // Add formatting options for all commands (skip if schema already defines json)
+    const hasJsonParam = config.parameters.some((p) => p.name === "json");
+    if (!hasJsonParam) {
+        command.option("--json", "Output raw JSON instead of formatted results");
+    }
     command.action(config.handler);
 }
 // ============================================================================
@@ -520,6 +535,14 @@ function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
         const camelKey = key.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
         const param = parameters.find((p) => p.name === camelKey);
         if (param && value !== undefined) {
+            // Skip empty arrays — Commander initializes repeatable options with []
+            // so an empty array means the user didn't pass the flag. Omitting it
+            // lets Zod's .default() supply the intended default value.
+            if (param.type === "array" &&
+                Array.isArray(value) &&
+                value.length === 0) {
+                return;
+            }
             sdkParams[camelKey] = convertValue(value, param.type);
         }
     });
@@ -538,8 +561,20 @@ function convertValue(value, type) {
         case "array":
             return Array.isArray(value) ? value : [value];
         case "string":
+            return value;
+        case "object":
+            // Parse JSON string to object for z.record() and similar types
+            if (typeof value === "string") {
+                try {
+                    return JSON.parse(value);
+                }
+                catch {
+                    return value;
+                }
+            }
+            return value;
         default:
-            // Handle JSON string for objects
+            // Unknown schema types - try to parse if it looks like JSON
             if (typeof value === "string" &&
                 (value.startsWith("{") || value.startsWith("["))) {
                 try {