@zapier/zapier-sdk-cli 0.9.0 → 0.10.0

package/dist/index.mjs

@@ -1044,26 +1044,25 @@ var addPlugin = ({ sdk, context }) => {
       console.log(`\u{1F510} Found ${authentications.length} authentication(s)`);
     }
     for (const app of apps) {
-      console.log(`\u{1F4E6} Adding ${app.key}...`);
+      const appSlugAndKey = app.slug ? `${app.slug} (${app.key})` : app.key;
+      console.log(`\u{1F4E6} Adding ${appSlugAndKey}...`);
       try {
-        const currentImplementationId = app.current_implementation_id;
-        const [implementationName, version] = currentImplementationId.split("@");
-        if (!implementationName || !version) {
+        if (!app.version) {
           console.warn(
-            `\u26A0\uFE0F Invalid implementation ID format for '${app.key}': ${currentImplementationId}. Expected format: <implementationName>@<version>. Skipping...`
+            `\u26A0\uFE0F Invalid implementation ID format for '${appSlugAndKey}': ${app.implementation_id}. Expected format: <implementationName>@<version>. Skipping...`
           );
           continue;
         }
         const [manifestKey] = await context.updateManifestEntry(
           app.key,
           {
-            implementationName,
-            version
+            implementationName: app.key,
+            version: app.version
           },
           configPath
         );
         console.log(
-          `\u{1F4DD} Locked ${app.key} to ${implementationName}@${version} using key '${manifestKey}'`
+          `\u{1F4DD} Locked ${appSlugAndKey} to ${app.key}@${app.version} using key '${manifestKey}'`
         );
         let authenticationId;
         if (authentications.length > 0) {
@@ -1073,10 +1072,12 @@ var addPlugin = ({ sdk, context }) => {
           if (matchingAuth) {
             authenticationId = matchingAuth.id;
             console.log(
-              `\u{1F510} Using authentication ${authenticationId} (${matchingAuth.title}) for ${app.key}`
+              `\u{1F510} Using authentication ${authenticationId} (${matchingAuth.title}) for ${appSlugAndKey}`
             );
           } else {
-            console.warn(`\u26A0\uFE0F No matching authentication found for ${app.key}`);
+            console.warn(
+              `\u26A0\uFE0F No matching authentication found for ${appSlugAndKey}`
+            );
           }
         }
         const typesPath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
@@ -1090,10 +1091,12 @@ var addPlugin = ({ sdk, context }) => {
           await writeFile(typesPath, typeDefinitions, "utf8");
           console.log(`\u{1F527} Generated types for ${manifestKey} at ${typesPath}`);
         } catch (error) {
-          console.warn(`\u26A0\uFE0F Failed to generate types for ${app.key}: ${error}`);
+          console.warn(
+            `\u26A0\uFE0F Failed to generate types for ${appSlugAndKey}: ${error}`
+          );
         }
       } catch (error) {
-        console.warn(`\u26A0\uFE0F Failed to process ${app.key}: ${error}`);
+        console.warn(`\u26A0\uFE0F Failed to process ${appSlugAndKey}: ${error}`);
       }
     }
     console.log(`\u2705 Added ${apps.length} app(s) to manifest`);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zapier/zapier-sdk-cli",
-    "version": "0.9.0",
+    "version": "0.10.0",
     "description": "Command line interface for Zapier SDK",
     "main": "dist/index.cjs",
     "module": "dist/index.mjs",

package/dist/src/plugins/add/index.js

@@ -53,21 +53,19 @@ export const addPlugin = ({ sdk, context }) => {
         }
         // Process each app
         for (const app of apps) {
-            console.log(`📦 Adding ${app.key}...`);
+            const appSlugAndKey = app.slug ? `${app.slug} (${app.key})` : app.key;
+            console.log(`📦 Adding ${appSlugAndKey}...`);
             try {
-                // Extract implementation name and version from current_implementation_id
-                const currentImplementationId = app.current_implementation_id;
-                const [implementationName, version] = currentImplementationId.split("@");
-                if (!implementationName || !version) {
-                    console.warn(`⚠️ Invalid implementation ID format for '${app.key}': ${currentImplementationId}. Expected format: <implementationName>@<version>. Skipping...`);
+                if (!app.version) {
+                    console.warn(`⚠️ Invalid implementation ID format for '${appSlugAndKey}': ${app.implementation_id}. Expected format: <implementationName>@<version>. Skipping...`);
                     continue;
                 }
                 // Update manifest using manifest plugin's function
                 const [manifestKey] = await context.updateManifestEntry(app.key, {
-                    implementationName,
-                    version,
+                    implementationName: app.key,
+                    version: app.version,
                 }, configPath);
-                console.log(`📝 Locked ${app.key} to ${implementationName}@${version} using key '${manifestKey}'`);
+                console.log(`📝 Locked ${appSlugAndKey} to ${app.key}@${app.version} using key '${manifestKey}'`);
                 // Find matching authentication for this app if authentications were provided
                 let authenticationId;
                 if (authentications.length > 0) {
@@ -77,10 +75,10 @@ export const addPlugin = ({ sdk, context }) => {
                     });
                     if (matchingAuth) {
                         authenticationId = matchingAuth.id;
-                        console.log(`🔐 Using authentication ${authenticationId} (${matchingAuth.title}) for ${app.key}`);
+                        console.log(`🔐 Using authentication ${authenticationId} (${matchingAuth.title}) for ${appSlugAndKey}`);
                     }
                     else {
-                        console.warn(`⚠️ No matching authentication found for ${app.key}`);
+                        console.warn(`⚠️ No matching authentication found for ${appSlugAndKey}`);
                     }
                 }
                 // Generate types using the manifest key for consistency
@@ -98,12 +96,12 @@ export const addPlugin = ({ sdk, context }) => {
                     console.log(`🔧 Generated types for ${manifestKey} at ${typesPath}`);
                 }
                 catch (error) {
-                    console.warn(`⚠️ Failed to generate types for ${app.key}: ${error}`);
+                    console.warn(`⚠️ Failed to generate types for ${appSlugAndKey}: ${error}`);
                     // Continue even if type generation fails
                 }
             }
             catch (error) {
-                console.warn(`⚠️ Failed to process ${app.key}: ${error}`);
+                console.warn(`⚠️ Failed to process ${appSlugAndKey}: ${error}`);
             }
         }
         console.log(`✅ Added ${apps.length} app(s) to manifest`);

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

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { type FunctionRegistryEntry } from "@zapier/zapier-sdk";
 export interface CliParameter {
     name: string;
     type: "string" | "number" | "boolean" | "array";
@@ -9,5 +10,5 @@ export interface CliParameter {
     hasResolver?: boolean;
     isPositional?: boolean;
 }
-export declare function analyzeZodSchema(schema: z.ZodSchema): CliParameter[];
+export declare function analyzeZodSchema(schema: z.ZodSchema, functionInfo?: FunctionRegistryEntry): CliParameter[];
 export declare function convertCliArgsToSdkParams(parameters: CliParameter[], positionalArgs: unknown[], options: Record<string, unknown>): Record<string, unknown>;

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

@@ -1,14 +1,14 @@
 import { z } from "zod";
-import { hasResolver, isPositional } from "@zapier/zapier-sdk";
+import { isPositional } from "@zapier/zapier-sdk";
 // ============================================================================
 // Schema Analysis
 // ============================================================================
-export function analyzeZodSchema(schema) {
+export function analyzeZodSchema(schema, functionInfo) {
     const parameters = [];
     if (schema instanceof z.ZodObject) {
         const shape = schema.shape;
         for (const [key, fieldSchema] of Object.entries(shape)) {
-            const param = analyzeZodField(key, fieldSchema);
+            const param = analyzeZodField(key, fieldSchema, functionInfo);
             if (param) {
                 parameters.push(param);
             }
@@ -16,7 +16,7 @@ export function analyzeZodSchema(schema) {
     }
     return parameters;
 }
-function analyzeZodField(name, schema) {
+function analyzeZodField(name, schema, functionInfo) {
     let baseSchema = schema;
     let required = true;
     let defaultValue = undefined;
@@ -53,6 +53,12 @@ function analyzeZodField(name, schema) {
         // Handle Record<string, any> as JSON string input
         paramType = "string";
     }
+    // Check if this parameter has a resolver
+    let paramHasResolver = false;
+    // Check function-specific resolvers first
+    if (functionInfo?.resolvers?.[name]) {
+        paramHasResolver = true;
+    }
     // Extract resolver metadata
     return {
         name,
@@ -61,7 +67,7 @@ function analyzeZodField(name, schema) {
         description: schema.description,
         default: defaultValue,
         choices,
-        hasResolver: hasResolver(name),
+        hasResolver: paramHasResolver,
         isPositional: isPositional(schema),
     };
 }

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

@@ -1,34 +1,13 @@
 import { z } from "zod";
-import { hasResolver, isPositional, formatErrorMessage, ZapierError, } from "@zapier/zapier-sdk";
+import { isPositional, formatErrorMessage, ZapierError, } from "@zapier/zapier-sdk";
 import { SchemaParameterResolver } from "./parameter-resolver";
-import { formatItemsFromSchema } from "./schema-formatter";
+import { formatItemsFromSchema, formatJsonOutput } from "./schema-formatter";
 import chalk from "chalk";
-import util from "util";
 import inquirer from "inquirer";
 // ============================================================================
-// JSON Formatting
-// ============================================================================
-function formatJsonOutput(data) {
-    // Don't print anything for undefined results (commands that just perform actions)
-    if (data === undefined) {
-        return;
-    }
-    // Show success message for action results
-    if (data &&
-        typeof data === "object" &&
-        !Array.isArray(data) &&
-        (data.success !== undefined ||
-            data.id ||
-            data.status)) {
-        console.log(chalk.green("✅ Action completed successfully!\n"));
-    }
-    // Use util.inspect for colored output
-    console.log(util.inspect(data, { colors: true, depth: null, breakLength: 80 }));
-}
-// ============================================================================
 // Schema Analysis
 // ============================================================================
-function analyzeZodSchema(schema) {
+function analyzeZodSchema(schema, functionInfo) {
     const parameters = [];
     // Handle ZodEffects (schemas with .refine(), .transform(), etc.)
     if (schema._def &&
@@ -37,12 +16,12 @@ function analyzeZodSchema(schema) {
         // Get the underlying schema
         const innerSchema = schema
             ._def.schema;
-        return analyzeZodSchema(innerSchema);
+        return analyzeZodSchema(innerSchema, functionInfo);
     }
     if (schema instanceof z.ZodObject) {
         const shape = schema.shape;
         for (const [key, fieldSchema] of Object.entries(shape)) {
-            const param = analyzeZodField(key, fieldSchema);
+            const param = analyzeZodField(key, fieldSchema, functionInfo);
             if (param) {
                 parameters.push(param);
             }
@@ -50,7 +29,7 @@ function analyzeZodSchema(schema) {
     }
     return parameters;
 }
-function analyzeZodField(name, schema) {
+function analyzeZodField(name, schema, functionInfo) {
     let baseSchema = schema;
     let required = true;
     let defaultValue = undefined;
@@ -98,6 +77,12 @@ function analyzeZodField(name, schema) {
         // Handle Record<string, any> as JSON string input
         paramType = "string";
     }
+    // Check if this parameter has a resolver
+    let paramHasResolver = false;
+    // Check function-specific resolvers first
+    if (functionInfo?.resolvers?.[name]) {
+        paramHasResolver = true;
+    }
     // Extract resolver metadata
     return {
         name,
@@ -106,7 +91,7 @@ function analyzeZodField(name, schema) {
         description: schema.description,
         default: defaultValue,
         choices,
-        hasResolver: hasResolver(name),
+        hasResolver: paramHasResolver,
         isPositional: isPositional(schema),
     };
 }
@@ -145,7 +130,7 @@ export function generateCliCommands(program, sdk) {
         }
         // Convert methodName to kebab-case CLI command
         const cliCommandName = methodNameToCliCommand(fnInfo.name);
-        const config = createCommandConfig(cliCommandName, fnInfo.name, fnInfo.inputSchema, sdk);
+        const config = createCommandConfig(cliCommandName, fnInfo, sdk);
         addCommand(program, cliCommandName, config);
     });
     // Override the help display to show commands grouped by category
@@ -200,8 +185,9 @@ export function generateCliCommands(program, sdk) {
         },
     });
 }
-function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
-    const parameters = analyzeZodSchema(schema);
+function createCommandConfig(cliCommandName, functionInfo, sdk) {
+    const schema = functionInfo.inputSchema;
+    const parameters = analyzeZodSchema(schema, functionInfo);
     const description = schema.description || `${cliCommandName} command`;
     const handler = async (...args) => {
         try {
@@ -209,7 +195,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
             const commandObj = args[args.length - 1];
             const options = commandObj.opts();
             // Check if this is a list command for pagination
-            const isListCommand = cliCommandName.startsWith("list-");
+            const isListCommand = functionInfo.type === "list";
             const hasPaginationParams = parameters.some((p) => p.name === "maxItems" || p.name === "pageSize");
             const hasUserSpecifiedMaxItems = "maxItems" in options && options.maxItems !== undefined;
             const shouldUseJson = options.json;
@@ -217,7 +203,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
             const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
             // Resolve missing parameters interactively using schema metadata
             const resolver = new SchemaParameterResolver();
-            const resolvedParams = await resolver.resolveParameters(schema, rawParams, sdk);
+            const resolvedParams = await resolver.resolveParameters(schema, rawParams, sdk, functionInfo.name);
             // Handle paginated list commands with async iteration
             if (isListCommand &&
                 hasPaginationParams &&
@@ -225,8 +211,8 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
                 !hasUserSpecifiedMaxItems) {
                 // Get the async iterable directly from the SDK method call (don't await it! that breaks the next page behavior)
                 const sdkObj = sdk;
-                const sdkIterator = sdkObj[sdkMethodName](resolvedParams);
-                await handlePaginatedListWithAsyncIteration(sdkMethodName, sdkIterator, schema);
+                const sdkIterator = sdkObj[functionInfo.name](resolvedParams);
+                await handlePaginatedListWithAsyncIteration(functionInfo.name, sdkIterator, functionInfo);
             }
             else {
                 // Special handling for commands that write to files
@@ -234,14 +220,14 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
                 if (hasOutputFile) {
                     // Call the SDK method for file output commands
                     const sdkObj = sdk;
-                    await sdkObj[sdkMethodName](resolvedParams);
+                    await sdkObj[functionInfo.name](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 sdkObj = sdk;
-                const result = await sdkObj[sdkMethodName](resolvedParams);
+                const result = await sdkObj[functionInfo.name](resolvedParams);
                 const items = result?.data
                     ? result.data
                     : result;
@@ -249,7 +235,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
                     console.log(JSON.stringify(items, null, 2));
                 }
                 else if (isListCommand) {
-                    formatNonPaginatedResults(items, resolvedParams.maxItems, hasUserSpecifiedMaxItems, shouldUseJson, schema, sdkMethodName);
+                    formatNonPaginatedResults(items, resolvedParams.maxItems, hasUserSpecifiedMaxItems, shouldUseJson, functionInfo);
                 }
                 else {
                     formatJsonOutput(items);
@@ -373,6 +359,10 @@ function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
     return sdkParams;
 }
 function convertValue(value, type) {
+    // Don't convert undefined values - let the resolver system handle them
+    if (value === undefined) {
+        return undefined;
+    }
     switch (type) {
         case "number":
             return Number(value);
@@ -398,11 +388,11 @@ function convertValue(value, type) {
 // ============================================================================
 // Pagination Handlers
 // ============================================================================
-async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, schema) {
-    const itemName = getItemNameFromMethod(sdkMethodName);
+async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, functionInfo) {
+    const itemName = getItemNameFromMethod(functionInfo);
     let totalShown = 0;
     let pageCount = 0;
-    console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
+    console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`));
     try {
         // Use async iteration to go through pages
         for await (const page of sdkResult) {
@@ -422,11 +412,11 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
             // Clear screen for subsequent pages (not the first)
             if (pageCount > 1) {
                 console.clear();
-                console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
+                console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`));
             }
-            // Format and display items using schema
-            if (schema) {
-                formatItemsFromSchema(schema, items, totalShown);
+            // Format and display items using function info
+            if (functionInfo) {
+                formatItemsFromSchema(functionInfo, items, totalShown);
             }
             else {
                 formatItemsGeneric(items, totalShown);
@@ -462,8 +452,8 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
                 console.log(chalk.yellow(`No ${itemName} found.`));
                 return;
             }
-            if (schema) {
-                formatItemsFromSchema(schema, items, 0);
+            if (functionInfo) {
+                formatItemsFromSchema(functionInfo, items, 0);
             }
             else {
                 formatItemsGeneric(items, 0);
@@ -475,7 +465,7 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
         }
     }
 }
-function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxItems, useRawJson, schema, methodName) {
+function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxItems, useRawJson, functionInfo) {
     if (!Array.isArray(result)) {
         if (useRawJson) {
             console.log(JSON.stringify(result, null, 2));
@@ -489,15 +479,15 @@ function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxIt
         console.log(JSON.stringify(result, null, 2));
         return;
     }
-    const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
+    const itemName = functionInfo ? getItemNameFromMethod(functionInfo) : "items";
     if (result.length === 0) {
         console.log(chalk.yellow(`No ${itemName} found.`));
         return;
     }
     console.log(chalk.green(`\n✅ Found ${result.length} ${itemName}:\n`));
-    // Use schema for formatting
-    if (schema) {
-        formatItemsFromSchema(schema, result);
+    // Use function info for formatting
+    if (functionInfo) {
+        formatItemsFromSchema(functionInfo, result);
     }
     else {
         // Fallback to generic formatting
@@ -524,20 +514,15 @@ function formatItemsGeneric(items, startingNumber = 0) {
     });
 }
 // Generic helper functions that infer from schema description or method name
-function getItemNameFromMethod(methodName) {
-    // Extract from method name: listApps -> apps, listActions -> actions
-    const listMatch = methodName.match(/^list(.+)$/);
-    if (listMatch) {
-        return listMatch[1].toLowerCase();
+function getItemNameFromMethod(functionInfo) {
+    if (functionInfo.itemType) {
+        return `${functionInfo.itemType} items`;
     }
-    // Fallback to generic
     return "items";
 }
-function getListTitleFromMethod(methodName) {
-    const itemName = getItemNameFromMethod(methodName);
-    if (itemName === "items")
-        return "Available Items";
-    // Capitalize first letter: apps -> Apps
-    const capitalized = itemName.charAt(0).toUpperCase() + itemName.slice(1);
-    return `Available ${capitalized}`;
+function getListTitleFromMethod(methodName, functionInfo) {
+    if (functionInfo.itemType) {
+        return `Available ${functionInfo.itemType} items`;
+    }
+    return `${methodName} items`;
 }

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import type { ZapierSdk } from "@zapier/zapier-sdk";
 export declare class SchemaParameterResolver {
-    resolveParameters(schema: z.ZodSchema, providedParams: unknown, sdk: ZapierSdk): Promise<unknown>;
+    resolveParameters(schema: z.ZodSchema, providedParams: unknown, sdk: ZapierSdk, functionName?: string): Promise<unknown>;
     private extractParametersFromSchema;
     private analyzeFieldSchema;
     private createResolvableParameter;
@@ -11,4 +11,7 @@ export declare class SchemaParameterResolver {
     private setNestedValue;
     private promptForField;
     private isUserCancellation;
+    private hasResolver;
+    private getResolver;
+    private getLocalResolvers;
 }