@zapier/zapier-sdk-cli 0.9.0 → 0.10.0

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

@@ -1,17 +1,59 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { z } from "zod";
-import { getResolver, hasResolver, getResolutionOrderForParams, } from "@zapier/zapier-sdk";
+// ============================================================================
+// Local Resolution Helper Functions
+// ============================================================================
+/**
+ * Resolve dependency chain for a parameter using local resolvers
+ * Returns parameters in the order they need to be resolved
+ */
+function getLocalResolutionOrder(paramName, resolvers, resolved = new Set()) {
+    const resolver = resolvers[paramName];
+    if (!resolver || resolver.type === "static") {
+        return [paramName];
+    }
+    const order = [];
+    if ("depends" in resolver && resolver.depends) {
+        for (const dependency of resolver.depends) {
+            if (!resolved.has(dependency)) {
+                order.push(...getLocalResolutionOrder(dependency, resolvers, resolved));
+                resolved.add(dependency);
+            }
+        }
+    }
+    if (!resolved.has(paramName)) {
+        order.push(paramName);
+        resolved.add(paramName);
+    }
+    return order;
+}
+/**
+ * Get resolution order for multiple parameters using local resolvers
+ */
+function getLocalResolutionOrderForParams(paramNames, resolvers) {
+    const resolved = new Set();
+    const order = [];
+    for (const paramName of paramNames) {
+        const paramOrder = getLocalResolutionOrder(paramName, resolvers, resolved);
+        for (const param of paramOrder) {
+            if (!order.includes(param)) {
+                order.push(param);
+            }
+        }
+    }
+    return order;
+}
 // ============================================================================
 // Schema Parameter Resolver
 // ============================================================================
 export class SchemaParameterResolver {
-    async resolveParameters(schema, providedParams, sdk) {
+    async resolveParameters(schema, providedParams, sdk, functionName) {
         // 1. Try to parse with current parameters
         const parseResult = schema.safeParse(providedParams);
         // Get all schema parameters to check which ones have resolvers
         const allParams = this.extractParametersFromSchema(schema);
-        const resolvableParams = allParams.filter((param) => hasResolver(param.name));
+        const resolvableParams = allParams.filter((param) => this.hasResolver(param.name, sdk, functionName));
         // Get all missing parameters that have resolvers
         const missingResolvable = resolvableParams.filter((param) => {
             const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
@@ -61,10 +103,13 @@ export class SchemaParameterResolver {
             sdk,
             currentParams: providedParams,
             resolvedParams,
+            functionName,
         };
+        // Get local resolvers for this function
+        const localResolvers = this.getLocalResolvers(sdk, functionName);
         if (functionallyRequired.length > 0) {
             const requiredParamNames = functionallyRequired.map((p) => p.name);
-            const requiredResolutionOrder = getResolutionOrderForParams(requiredParamNames);
+            const requiredResolutionOrder = getLocalResolutionOrderForParams(requiredParamNames, localResolvers);
             // Find all parameters that need to be resolved (including dependencies)
             // from the available resolvable parameters
             const orderedRequiredParams = requiredResolutionOrder
@@ -84,7 +129,7 @@ export class SchemaParameterResolver {
                 .filter((param) => param !== undefined);
             for (const param of orderedRequiredParams) {
                 try {
-                    const value = await this.resolveParameter(param, context);
+                    const value = await this.resolveParameter(param, context, functionName);
                     this.setNestedValue(resolvedParams, param.path, value);
                     // Update context with newly resolved value
                     context.resolvedParams = resolvedParams;
@@ -105,13 +150,13 @@ export class SchemaParameterResolver {
         // 3. Resolve parameters that should always be prompted for (but can be skipped)
         if (alwaysPrompt.length > 0) {
             const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
-            const alwaysPromptResolutionOrder = getResolutionOrderForParams(alwaysPromptNames);
+            const alwaysPromptResolutionOrder = getLocalResolutionOrderForParams(alwaysPromptNames, localResolvers);
             const orderedAlwaysPromptParams = alwaysPromptResolutionOrder
                 .map((paramName) => alwaysPrompt.find((p) => p.name === paramName))
                 .filter((param) => param !== undefined);
             for (const param of orderedAlwaysPromptParams) {
                 try {
-                    const value = await this.resolveParameter(param, context);
+                    const value = await this.resolveParameter(param, context, functionName);
                     this.setNestedValue(resolvedParams, param.path, value);
                     // Update context with newly resolved value
                     context.resolvedParams = resolvedParams;
@@ -139,13 +184,13 @@ export class SchemaParameterResolver {
             if (shouldResolveOptional.resolveOptional) {
                 // Resolve optional parameters using their resolvers
                 const optionalParamNames = trulyOptional.map((p) => p.name);
-                const optionalResolutionOrder = getResolutionOrderForParams(optionalParamNames);
+                const optionalResolutionOrder = getLocalResolutionOrderForParams(optionalParamNames, localResolvers);
                 const orderedOptionalParams = optionalResolutionOrder
                     .map((paramName) => trulyOptional.find((p) => p.name === paramName))
                     .filter((param) => param !== undefined);
                 for (const param of orderedOptionalParams) {
                     try {
-                        const value = await this.resolveParameter(param, context);
+                        const value = await this.resolveParameter(param, context, functionName);
                         this.setNestedValue(resolvedParams, param.path, value);
                         // Update context with newly resolved value
                         context.resolvedParams = resolvedParams;
@@ -208,8 +253,8 @@ export class SchemaParameterResolver {
             isRequired,
         };
     }
-    async resolveParameter(param, context) {
-        const resolver = getResolver(param.name);
+    async resolveParameter(param, context, functionName) {
+        const resolver = this.getResolver(param.name, context.sdk, functionName);
         if (!resolver) {
             throw new Error(`No resolver found for parameter: ${param.name}`);
         }
@@ -285,8 +330,8 @@ export class SchemaParameterResolver {
                 break;
             }
             // Separate new required and optional fields
-            const newRequiredFields = newFields.filter((field) => field.required);
-            const newOptionalFields = newFields.filter((field) => !field.required);
+            const newRequiredFields = newFields.filter((field) => field.is_required);
+            const newOptionalFields = newFields.filter((field) => !field.is_required);
             // Prompt for new required fields
             if (newRequiredFields.length > 0) {
                 console.log(chalk.blue(`\n📝 Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`));
@@ -358,7 +403,7 @@ export class SchemaParameterResolver {
         const fieldPrompt = {
             type: fieldObj.type === "boolean" ? "confirm" : "input",
             name: fieldObj.key,
-            message: `${fieldObj.label || fieldObj.key}${fieldObj.required ? " (required)" : " (optional)"}:`,
+            message: `${fieldObj.label || fieldObj.key}${fieldObj.is_required ? " (required)" : " (optional)"}:`,
         };
         if (fieldObj.helpText) {
             fieldPrompt.prefix = chalk.gray(`ℹ ${fieldObj.helpText}\n`);
@@ -381,7 +426,7 @@ export class SchemaParameterResolver {
             if (answer[fieldObj.key] !== undefined && answer[fieldObj.key] !== "") {
                 inputs[fieldObj.key] = answer[fieldObj.key];
             }
-            else if (fieldObj.required) {
+            else if (fieldObj.is_required) {
                 throw new Error(`Required field ${fieldObj.key} cannot be empty`);
             }
         }
@@ -399,4 +444,36 @@ export class SchemaParameterResolver {
             errorObj?.message?.includes("User force closed") ||
             errorObj?.isTTYError === true);
     }
+    hasResolver(paramName, sdk, functionName) {
+        // Check plugin-specific resolvers first
+        if (functionName && typeof sdk.getRegistry === "function") {
+            const registry = sdk.getRegistry();
+            const functionInfo = registry.functions.find((f) => f.name === functionName);
+            if (functionInfo && functionInfo.resolvers?.[paramName]) {
+                return true;
+            }
+        }
+        // No global registry fallback
+        return false;
+    }
+    getResolver(paramName, sdk, functionName) {
+        // Check plugin-specific resolvers first
+        if (functionName && typeof sdk.getRegistry === "function") {
+            const registry = sdk.getRegistry();
+            const functionInfo = registry.functions.find((f) => f.name === functionName);
+            if (functionInfo && functionInfo.resolvers?.[paramName]) {
+                return functionInfo.resolvers[paramName];
+            }
+        }
+        // No global registry fallback
+        return null;
+    }
+    getLocalResolvers(sdk, functionName) {
+        if (!functionName || typeof sdk.getRegistry !== "function") {
+            return {};
+        }
+        const registry = sdk.getRegistry();
+        const functionInfo = registry.functions.find((f) => f.name === functionName);
+        return functionInfo?.resolvers || {};
+    }
 }

package/dist/src/utils/schema-formatter.d.ts

@@ -1,2 +1,6 @@
 import type { z } from "zod";
-export declare function formatItemsFromSchema(inputSchema: z.ZodType, items: unknown[], startingNumber?: number): void;
+export declare function formatJsonOutput(data: unknown): void;
+export declare function formatItemsFromSchema(functionInfo: {
+    inputSchema: z.ZodType;
+    outputSchema?: z.ZodType;
+}, items: unknown[], startingNumber?: number): void;

package/dist/src/utils/schema-formatter.js

@@ -1,4 +1,5 @@
 import chalk from "chalk";
+import util from "util";
 function getFormatMetadata(schema) {
     return schema?._def
         ?.formatMeta;
@@ -7,11 +8,22 @@ function getOutputSchema(schema) {
     return schema?._def?.outputSchema;
 }
 // ============================================================================
+// JSON Formatting
+// ============================================================================
+export function formatJsonOutput(data) {
+    // Don't print anything for undefined results (commands that just perform actions)
+    if (data === undefined) {
+        return;
+    }
+    // Use util.inspect for colored output
+    console.log(util.inspect(data, { colors: true, depth: null, breakLength: 80 }));
+}
+// ============================================================================
 // Generic Schema-Driven Formatter
 // ============================================================================
-export function formatItemsFromSchema(inputSchema, items, startingNumber = 0) {
-    // Get the output schema and its format metadata
-    const outputSchema = getOutputSchema(inputSchema);
+export function formatItemsFromSchema(functionInfo, items, startingNumber = 0) {
+    // Get the output schema from function info or fall back to input schema output schema
+    const outputSchema = functionInfo.outputSchema || getOutputSchema(functionInfo.inputSchema);
     if (!outputSchema) {
         // Fallback to generic formatting if no output schema
         formatItemsGeneric(items, startingNumber);
@@ -25,18 +37,31 @@ export function formatItemsFromSchema(inputSchema, items, startingNumber = 0) {
     }
     // Format each item using the schema metadata
     items.forEach((item, index) => {
-        formatSingleItem(item, startingNumber + index, formatMeta);
+        const formatted = formatMeta.format(item);
+        formatSingleItem(formatted, startingNumber + index);
     });
 }
-function formatSingleItem(item, itemNumber, formatMeta) {
-    // Get the formatted item from the format function
-    const formatted = formatMeta.format(item);
-    // Build the main title line
+function formatSingleItem(formatted, itemNumber) {
+    // Build the main title line with optional subtitle
     let titleLine = `${chalk.gray(`${itemNumber + 1}.`)} ${chalk.cyan(formatted.title)}`;
-    if (formatted.subtitle) {
-        titleLine += ` ${chalk.gray(formatted.subtitle)}`;
+    // Generate subtitle from id or key
+    if (formatted.id) {
+        titleLine += ` ${chalk.gray(`(ID: ${formatted.id})`)}`;
+    }
+    else if (formatted.key) {
+        titleLine += ` ${chalk.gray(`(${formatted.key})`)}`;
     }
     console.log(titleLine);
+    // Show description if available
+    if (formatted.description) {
+        console.log(`   ${chalk.dim(formatted.description)}`);
+    }
+    // If data is provided, use JSON formatting instead of details
+    if (formatted.data !== undefined) {
+        formatJsonOutput(formatted.data);
+        console.log(); // Empty line between items
+        return;
+    }
     // Format detail lines
     for (const detail of formatted.details) {
         const styledText = applyStyle(detail.text, detail.style);
@@ -59,15 +84,20 @@ function applyStyle(value, style) {
             return chalk.blue(value);
     }
 }
+function convertGenericItemToFormattedItem(item) {
+    const itemObj = item;
+    return {
+        title: itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item",
+        id: itemObj.id,
+        key: itemObj.key,
+        description: itemObj.description,
+        details: [],
+    };
+}
 function formatItemsGeneric(items, startingNumber = 0) {
-    // Fallback formatting for items without schema metadata
+    // Convert generic items to FormattedItem and use formatSingleItem
     items.forEach((item, index) => {
-        const itemObj = item;
-        const name = itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item";
-        console.log(`${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(name)}`);
-        if (itemObj.description) {
-            console.log(`   ${chalk.dim(itemObj.description)}`);
-        }
-        console.log();
+        const formatted = convertGenericItemToFormattedItem(item);
+        formatSingleItem(formatted, startingNumber + index);
     });
 }