@zapier/zapier-sdk-cli 0.8.4 → 0.10.0

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

package/tsup.config.ts

@@ -17,7 +17,7 @@ export default defineConfig({
     };
   },
   // Make the optional CLI login package external so it doesn't cause build issues
-  external: ["@zapier/zapier-sdk-cli-login"],
+  external: ["@zapier/zapier-sdk-cli-login", "typescript"],
   // Use the build-specific tsconfig for tsup
   tsconfig: "tsconfig.build.json",
 });

package/dist/src/plugins/generateTypes/index.d.ts

@@ -1,21 +0,0 @@
-import type { Plugin, GetSdkType, ListActionsPluginProvides, ListInputFieldsPluginProvides, ManifestPluginProvides } from "@zapier/zapier-sdk";
-import { GenerateTypesSchema, type GenerateTypesOptions } from "./schemas";
-export interface GenerateTypesPluginProvides {
-    generateTypes: (options: GenerateTypesOptions) => Promise<string>;
-    context: {
-        meta: {
-            generateTypes: {
-                inputSchema: typeof GenerateTypesSchema;
-            };
-        };
-    };
-}
-export declare const generateTypesPlugin: Plugin<GetSdkType<ListActionsPluginProvides & ListInputFieldsPluginProvides & ManifestPluginProvides>, // requires these SDK methods
-{}, // requires no context
-GenerateTypesPluginProvides>;
-/**
- * Generate TypeScript types for a specific app (CLI version)
- */
-export declare function generateTypes(options: GenerateTypesOptions & {
-    sdk: GetSdkType<ListActionsPluginProvides & ListInputFieldsPluginProvides & ManifestPluginProvides>;
-}): Promise<string>;

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

@@ -1,312 +0,0 @@
-import { GenerateTypesSchema } from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
-import * as fs from "fs";
-import * as path from "path";
-export const generateTypesPlugin = ({ sdk }) => {
-    const generateTypesWithSdk = createFunction(async function generateTypesWithSdk(options) {
-        return await generateTypes({ ...options, sdk });
-    }, GenerateTypesSchema);
-    return {
-        generateTypes: generateTypesWithSdk,
-        context: {
-            meta: {
-                generateTypes: {
-                    categories: ["utility"],
-                    inputSchema: GenerateTypesSchema,
-                },
-            },
-        },
-    };
-};
-/**
- * Generate the fetch method signature for app proxies
- */
-function generateFetchMethodSignature() {
-    return `  /** Make authenticated HTTP requests through Zapier's Relay service */
-  fetch: (options: Omit<z.infer<typeof RelayFetchSchema>, 'authenticationId'>) => Promise<Response>`;
-}
-/**
- * Generate TypeScript types for a specific app (CLI version)
- */
-export async function generateTypes(options) {
-    const { appKey, authenticationId, output = `./types/${appKey}.d.ts`, sdk, } = options;
-    // Parse app identifier (support app@version format)
-    const { app, version } = parseAppIdentifier(appKey);
-    // Fetch all actions for the app
-    const actionsResult = await sdk.listActions({
-        appKey: app,
-    });
-    const actions = actionsResult.data;
-    if (actions.length === 0) {
-        const typeDefinitions = generateEmptyTypesFile(app, version);
-        if (output) {
-            fs.mkdirSync(path.dirname(output), { recursive: true });
-            fs.writeFileSync(output, typeDefinitions, "utf8");
-        }
-        return typeDefinitions;
-    }
-    // Fetch input fields for each action
-    const actionsWithFields = [];
-    if (authenticationId) {
-        for (const action of actions) {
-            try {
-                // Check to see if the appKey is in the manifest
-                const manifestEntry = sdk.getContext().getManifestEntry(appKey);
-                const fieldsResult = await sdk.listInputFields({
-                    // If the appKey is in the manifest, use the appKey so that the types are consistent with the manifest's version, otherwise use the action.app_key
-                    appKey: manifestEntry ? appKey : action.app_key,
-                    actionKey: action.key,
-                    actionType: action.action_type,
-                    authenticationId: authenticationId,
-                });
-                const fields = fieldsResult.data.map((field) => {
-                    const fieldObj = field;
-                    return {
-                        ...fieldObj,
-                        required: fieldObj.is_required || fieldObj.required || false,
-                    };
-                });
-                actionsWithFields.push({
-                    ...action,
-                    inputFields: fields,
-                    name: action.title || action.key,
-                });
-            }
-            catch {
-                // If we can't get fields for an action, include it without fields
-                actionsWithFields.push({
-                    ...action,
-                    inputFields: [],
-                    name: action.title || action.key,
-                });
-            }
-        }
-    }
-    else {
-        // Convert actions to have empty input fields (will generate generic types)
-        actions.forEach((action) => {
-            actionsWithFields.push({
-                ...action,
-                inputFields: [],
-                name: action.title || action.key,
-            });
-        });
-    }
-    // Generate TypeScript types
-    const typeDefinitions = generateTypeDefinitions(app, actionsWithFields, version);
-    // Write to file if output path specified
-    if (output) {
-        fs.mkdirSync(path.dirname(output), { recursive: true });
-        fs.writeFileSync(output, typeDefinitions, "utf8");
-    }
-    return typeDefinitions;
-}
-function parseAppIdentifier(identifier) {
-    const parts = identifier.split("@");
-    return {
-        app: parts[0],
-        version: parts[1],
-    };
-}
-function generateTypeDefinitions(appKey, actions, version) {
-    // Handle empty actions
-    if (actions.length === 0) {
-        return generateEmptyTypesFile(appKey, version);
-    }
-    // Group actions by type
-    const actionsByType = actions.reduce((acc, action) => {
-        if (!acc[action.action_type]) {
-            acc[action.action_type] = [];
-        }
-        acc[action.action_type].push(action);
-        return acc;
-    }, {});
-    const appName = capitalize(appKey);
-    const versionComment = version
-        ? ` * Generated for ${appKey}@${version}`
-        : ` * Generated for ${appKey}`;
-    let output = `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${new Date().toISOString()}
- * 
- * Usage:
- *   import type { ${appName}Sdk } from './path/to/this/file'
- *   const sdk = createZapierSdk() as unknown as ${appName}Sdk
- *   
- *   // Direct usage (per-call auth):
- *   await sdk.apps.${appKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
- *   
- *   // Factory usage (pinned auth):
- *   const my${appName} = sdk.apps.${appKey}({ authenticationId: 123 })
- *   await my${appName}.search.user_by_email({ inputs: { email } })
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-`;
-    // Generate input types for each action
-    actions.forEach((action) => {
-        if (action.inputFields.length > 0) {
-            const inputTypeName = `${appName}${capitalize(action.action_type)}${capitalize(sanitizeActionName(action.key))}Inputs`;
-            output += `interface ${inputTypeName} {\n`;
-            action.inputFields.forEach((field) => {
-                const isOptional = !field.required;
-                const fieldType = mapFieldTypeToTypeScript(field);
-                const description = field.helpText
-                    ? `  /** ${escapeComment(field.helpText)} */\n`
-                    : "";
-                output += `${description}  ${sanitizeFieldName(field.key)}${isOptional ? "?" : ""}: ${fieldType}\n`;
-            });
-            output += `}\n\n`;
-        }
-    });
-    // Generate action type interfaces for each action type
-    Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
-        const typeName = `${appName}${capitalize(actionType)}Actions`;
-        output += `interface ${typeName} {\n`;
-        typeActions.forEach((action) => {
-            const actionName = sanitizeActionName(action.key);
-            const description = action.description
-                ? `  /** ${escapeComment(action.description)} */\n`
-                : "";
-            // Generate type-safe action method signature
-            if (action.inputFields.length > 0) {
-                const inputTypeName = `${appName}${capitalize(action.action_type)}${capitalize(sanitizeActionName(action.key))}Inputs`;
-                output += `${description}  ${actionName}: (options: { inputs: ${inputTypeName} } & Omit<ActionExecutionOptions, 'inputs'>) => Promise<ActionExecutionResult>\n`;
-            }
-            else {
-                // No specific input fields available - use generic Record<string, any> for inputs
-                output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>\n`;
-            }
-        });
-        output += `}\n\n`;
-    });
-    // Generate the main app SDK interface with factory pattern support
-    // Generate the app proxy interface (actions grouped by type)
-    output += `interface ${appName}AppProxy {\n`;
-    Object.keys(actionsByType).forEach((actionType) => {
-        const typeName = `${appName}${capitalize(actionType)}Actions`;
-        output += `  ${actionType}: ${typeName}\n`;
-    });
-    // Always include fetch method for authenticated HTTP requests
-    output += generateFetchMethodSignature() + "\n";
-    output += `}\n\n`;
-    // Generate the factory function interface
-    output += `interface ${appName}AppFactory {\n`;
-    output += `  (options: { authenticationId: number }): ${appName}AppProxy\n`;
-    output += `}\n\n`;
-    // Combine factory and direct access
-    output += `type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy\n\n`;
-    // Generate the main SDK interface
-    output += `export interface ${appName}Sdk {\n`;
-    output += `  apps: {\n`;
-    output += `    ${appKey}: ${appName}AppWithFactory\n`;
-    output += `  }\n`;
-    output += `}\n`;
-    return output;
-}
-function generateEmptyTypesFile(appKey, version) {
-    const appName = capitalize(appKey);
-    const versionComment = version
-        ? ` * Generated for ${appKey}@${version}`
-        : ` * Generated for ${appKey}`;
-    return `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${new Date().toISOString()}
- * 
- * No actions found for this app.
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-interface ${appName}AppProxy {
-  // No actions available
-${generateFetchMethodSignature()}
-}
-
-interface ${appName}AppFactory {
-  (options: { authenticationId: number }): ${appName}AppProxy
-}
-
-type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
-
-export interface ${appName}Sdk {
-  apps: {
-    ${appKey}: ${appName}AppWithFactory
-  }
-}
-`;
-}
-function capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-}
-function sanitizeActionName(actionKey) {
-    // Ensure the action name is a valid TypeScript identifier
-    let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-    // If it starts with a number, prepend an underscore
-    if (/^[0-9]/.test(sanitized)) {
-        sanitized = "_" + sanitized;
-    }
-    return sanitized;
-}
-function sanitizeFieldName(fieldKey) {
-    // Ensure the field name is a valid TypeScript identifier
-    let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-    // If it starts with a number, prepend an underscore
-    if (/^[0-9]/.test(sanitized)) {
-        sanitized = "_" + sanitized;
-    }
-    return sanitized;
-}
-function escapeComment(comment) {
-    // Escape comment text to prevent breaking the JSDoc comment
-    return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
-}
-function mapFieldTypeToTypeScript(field) {
-    // Handle choices (enum-like fields)
-    if (field.choices && field.choices.length > 0) {
-        const choiceValues = field.choices
-            .filter((choice) => choice.value !== undefined &&
-            choice.value !== null &&
-            choice.value !== "")
-            .map((choice) => typeof choice.value === "string" ? `"${choice.value}"` : choice.value);
-        if (choiceValues.length > 0) {
-            return choiceValues.join(" | ");
-        }
-        // If all choices were filtered out, fall through to default type handling
-    }
-    // Map Zapier field types to TypeScript types
-    switch (field.type?.toLowerCase()) {
-        case "string":
-        case "text":
-        case "email":
-        case "url":
-        case "password":
-            return "string";
-        case "integer":
-        case "number":
-            return "number";
-        case "boolean":
-            return "boolean";
-        case "datetime":
-        case "date":
-            return "string"; // ISO date strings
-        case "file":
-            return "string"; // File URL or content
-        case "array":
-            return "any[]";
-        case "object":
-            return "Record<string, any>";
-        default:
-            // Default to string for unknown types, with union for common cases
-            return "string | number | boolean";
-    }
-}

package/dist/src/plugins/generateTypes/schemas.d.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-export declare const GenerateTypesSchema: z.ZodObject<{
-    appKey: z.ZodString;
-    authenticationId: z.ZodOptional<z.ZodNumber>;
-    output: z.ZodOptional<z.ZodString>;
-    lockFilePath: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKey: string;
-    authenticationId?: number | undefined;
-    output?: string | undefined;
-    lockFilePath?: string | undefined;
-}, {
-    appKey: string;
-    authenticationId?: number | undefined;
-    output?: string | undefined;
-    lockFilePath?: string | undefined;
-}>;
-export type GenerateTypesOptions = z.infer<typeof GenerateTypesSchema>;

package/dist/src/plugins/generateTypes/schemas.js

@@ -1,14 +0,0 @@
-import { z } from "zod";
-import { AppKeyPropertySchema, AuthenticationIdPropertySchema, OutputPropertySchema, } from "@zapier/zapier-sdk";
-// Generate types schema - mirrors the original from SDK but for CLI use
-export const GenerateTypesSchema = z
-    .object({
-    appKey: AppKeyPropertySchema.describe("App key to generate SDK code for"),
-    authenticationId: AuthenticationIdPropertySchema.optional(),
-    output: OutputPropertySchema.optional().describe("Output file path (defaults to generated/<appKey>.ts)"),
-    lockFilePath: z
-        .string()
-        .optional()
-        .describe("Path to the .zapierrc lock file (defaults to .zapierrc)"),
-})
-    .describe("Generate TypeScript SDK code for a specific app");

package/dist/src/plugins/getConfigPath/index.d.ts

@@ -1,15 +0,0 @@
-import type { Plugin } from "@zapier/zapier-sdk";
-import { GetConfigPathSchema, type GetConfigPathOptions } from "./schemas";
-export interface GetConfigPathPluginProvides {
-    getConfigPath: (options?: GetConfigPathOptions) => Promise<string>;
-    context: {
-        meta: {
-            getConfigPath: {
-                inputSchema: typeof GetConfigPathSchema;
-            };
-        };
-    };
-}
-export declare const getConfigPathPlugin: Plugin<{}, // requires no existing SDK methods
-{}, // requires no context
-GetConfigPathPluginProvides>;

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

@@ -1,19 +0,0 @@
-import { GetConfigPathSchema } from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
-import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
-export const getConfigPathPlugin = () => {
-    const getConfigPathWithSdk = createFunction(async function getConfigPathWithSdk(_options) {
-        return getConfigPath();
-    }, GetConfigPathSchema);
-    return {
-        getConfigPath: getConfigPathWithSdk,
-        context: {
-            meta: {
-                getConfigPath: {
-                    categories: ["utility"],
-                    inputSchema: GetConfigPathSchema,
-                },
-            },
-        },
-    };
-};

package/dist/src/plugins/getConfigPath/schemas.d.ts

@@ -1,3 +0,0 @@
-import { z } from "zod";
-export declare const GetConfigPathSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export type GetConfigPathOptions = z.infer<typeof GetConfigPathSchema>;

package/dist/src/plugins/getConfigPath/schemas.js

@@ -1,5 +0,0 @@
-import { z } from "zod";
-// Get config path schema - simple command with no parameters
-export const GetConfigPathSchema = z
-    .object({})
-    .describe("Show the path to the configuration file");