@zapier/zapier-sdk-cli 0.9.0 → 0.10.0

package/src/utils/parameter-resolver.ts

@@ -2,11 +2,6 @@ import inquirer from "inquirer";
 import chalk from "chalk";
 import { z } from "zod";
 import type { ZapierSdk } from "@zapier/zapier-sdk";
-import {
-  getResolver,
-  hasResolver,
-  getResolutionOrderForParams,
-} from "@zapier/zapier-sdk";
 
 // ============================================================================
 // Types
@@ -24,6 +19,66 @@ interface ResolverContext {
   sdk: ZapierSdk;
   currentParams: Record<string, unknown>;
   resolvedParams: Record<string, unknown>;
+  functionName?: string;
+}
+
+// ============================================================================
+// 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: string,
+  resolvers: Record<string, any>,
+  resolved: Set<string> = new Set(),
+): string[] {
+  const resolver = resolvers[paramName];
+  if (!resolver || resolver.type === "static") {
+    return [paramName];
+  }
+
+  const order: string[] = [];
+
+  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: string[],
+  resolvers: Record<string, any>,
+): string[] {
+  const resolved = new Set<string>();
+  const order: string[] = [];
+
+  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;
 }
 
 // ============================================================================
@@ -35,6 +90,7 @@ export class SchemaParameterResolver {
     schema: z.ZodSchema,
     providedParams: unknown,
     sdk: ZapierSdk,
+    functionName?: string,
   ): Promise<unknown> {
     // 1. Try to parse with current parameters
     const parseResult = schema.safeParse(providedParams);
@@ -42,7 +98,7 @@ export class SchemaParameterResolver {
     // Get all schema parameters to check which ones have resolvers
     const allParams = this.extractParametersFromSchema(schema);
     const resolvableParams = allParams.filter((param) =>
-      hasResolver(param.name),
+      this.hasResolver(param.name, sdk, functionName),
     );
 
     // Get all missing parameters that have resolvers
@@ -108,12 +164,18 @@ export class SchemaParameterResolver {
       sdk,
       currentParams: providedParams as Record<string, unknown>,
       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
@@ -135,7 +197,11 @@ export class SchemaParameterResolver {
 
       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
@@ -168,8 +234,10 @@ 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))
@@ -177,7 +245,11 @@ export class SchemaParameterResolver {
 
       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
@@ -207,8 +279,10 @@ 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))
@@ -216,7 +290,11 @@ export class SchemaParameterResolver {
 
         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
@@ -306,8 +384,9 @@ export class SchemaParameterResolver {
   private async resolveParameter(
     param: ResolvableParameter,
     context: ResolverContext,
+    functionName?: string,
   ): Promise<unknown> {
-    const resolver = getResolver(param.name);
+    const resolver = this.getResolver(param.name, context.sdk, functionName);
     if (!resolver) {
       throw new Error(`No resolver found for parameter: ${param.name}`);
     }
@@ -430,10 +509,10 @@ export class SchemaParameterResolver {
 
       // Separate new required and optional fields
       const newRequiredFields = newFields.filter(
-        (field: unknown) => (field as { required: boolean }).required,
+        (field: unknown) => (field as { is_required: boolean }).is_required,
       );
       const newOptionalFields = newFields.filter(
-        (field: unknown) => !(field as { required: boolean }).required,
+        (field: unknown) => !(field as { is_required: boolean }).is_required,
       );
 
       // Prompt for new required fields
@@ -536,7 +615,7 @@ export class SchemaParameterResolver {
       type?: string;
       key: string;
       label?: string;
-      required?: boolean;
+      is_required?: boolean;
       helpText?: string;
       default?: unknown;
       choices?: Array<{ label?: string; value: unknown }>;
@@ -545,7 +624,7 @@ export class SchemaParameterResolver {
     const fieldPrompt: Record<string, unknown> = {
       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) {
@@ -574,7 +653,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`);
       }
     } catch (error) {
@@ -598,4 +677,59 @@ export class SchemaParameterResolver {
       errorObj?.isTTYError === true
     );
   }
+
+  private hasResolver(
+    paramName: string,
+    sdk: ZapierSdk,
+    functionName?: string,
+  ): boolean {
+    // 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;
+  }
+
+  private getResolver(
+    paramName: string,
+    sdk: ZapierSdk,
+    functionName?: string,
+  ): any {
+    // 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;
+  }
+
+  private getLocalResolvers(
+    sdk: ZapierSdk,
+    functionName?: string,
+  ): Record<string, any> {
+    if (!functionName || typeof sdk.getRegistry !== "function") {
+      return {};
+    }
+
+    const registry = sdk.getRegistry();
+    const functionInfo = registry.functions.find(
+      (f) => f.name === functionName,
+    );
+    return functionInfo?.resolvers || {};
+  }
 }

package/src/utils/schema-formatter.ts

@@ -1,11 +1,15 @@
 import chalk from "chalk";
 import type { z } from "zod";
+import util from "util";
 // These functions are internal to SDK, implementing basic formatting fallback
 // TODO: Consider exposing these utilities or implementing proper CLI formatting
 
 interface FormattedItem {
   title: string;
-  subtitle?: string;
+  id?: string;
+  key?: string;
+  description?: string;
+  data?: unknown; // Optional: if provided, use formatJsonOutput instead of details
   details: Array<{
     text: string;
     style: "normal" | "dim" | "accent" | "warning" | "success";
@@ -25,17 +29,34 @@ function getOutputSchema(schema: unknown): unknown {
   return (schema as { _def?: { outputSchema?: unknown } })?._def?.outputSchema;
 }
 
+// ============================================================================
+// JSON Formatting
+// ============================================================================
+
+export function formatJsonOutput(data: unknown): void {
+  // 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: z.ZodType,
+  functionInfo: { inputSchema: z.ZodType; outputSchema?: z.ZodType },
   items: unknown[],
   startingNumber: number = 0,
 ): void {
-  // Get the output schema and its format metadata
-  const outputSchema = getOutputSchema(inputSchema);
+  // 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);
@@ -51,25 +72,35 @@ export function formatItemsFromSchema(
 
   // 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: unknown,
-  itemNumber: number,
-  formatMeta: FormatMetadata,
-): void {
-  // Get the formatted item from the format function
-  const formatted = formatMeta.format(item);
-
-  // Build the main title line
+function formatSingleItem(formatted: FormattedItem, itemNumber: number): void {
+  // 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);
@@ -95,27 +126,31 @@ function applyStyle(value: string, style: string): string {
   }
 }
 
+function convertGenericItemToFormattedItem(item: unknown): FormattedItem {
+  const itemObj = item as {
+    title?: string;
+    name?: string;
+    key?: string;
+    id?: string;
+    description?: string;
+  };
+
+  return {
+    title: itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item",
+    id: itemObj.id,
+    key: itemObj.key,
+    description: itemObj.description,
+    details: [],
+  };
+}
+
 function formatItemsGeneric(
   items: unknown[],
   startingNumber: number = 0,
 ): void {
-  // Fallback formatting for items without schema metadata
+  // Convert generic items to FormattedItem and use formatSingleItem
   items.forEach((item, index) => {
-    const itemObj = item as {
-      title?: string;
-      name?: string;
-      key?: string;
-      id?: string;
-      description?: string;
-    };
-    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);
   });
 }