@zapier/zapier-sdk-cli 0.34.9 → 0.34.11

package/dist/index.cjs

@@ -2016,7 +2016,10 @@ var cliOverridesPlugin = ({ context }) => {
       meta: {
         fetch: {
           ...context.meta.fetch,
-          categories: [...context.meta.fetch.categories || [], "deprecated"]
+          categories: [...context.meta.fetch.categories || [], "deprecated"],
+          deprecation: {
+            message: "This command is deprecated and will be removed soon. Use `curl` instead. Learn more: https://docs.zapier.com/sdk/cli-reference#curl"
+          }
         }
       }
     }
@@ -2504,7 +2507,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default = {
-  version: "0.34.9"};
+  version: "0.34.11"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {

package/dist/index.mjs

@@ -1983,7 +1983,10 @@ var cliOverridesPlugin = ({ context }) => {
       meta: {
         fetch: {
           ...context.meta.fetch,
-          categories: [...context.meta.fetch.categories || [], "deprecated"]
+          categories: [...context.meta.fetch.categories || [], "deprecated"],
+          deprecation: {
+            message: "This command is deprecated and will be removed soon. Use `curl` instead. Learn more: https://docs.zapier.com/sdk/cli-reference#curl"
+          }
         }
       }
     }
@@ -2471,7 +2474,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default = {
-  version: "0.34.9"};
+  version: "0.34.11"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {

package/dist/package.json

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

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

@@ -1,6 +1,7 @@
-import type { Plugin } from "@zapier/zapier-sdk";
+import type { FunctionDeprecation, Plugin } from "@zapier/zapier-sdk";
 interface FetchMeta {
     categories?: string[];
+    deprecation?: FunctionDeprecation;
 }
 interface CliOverridesProvides {
     context: {

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

@@ -12,6 +12,9 @@ export const cliOverridesPlugin = ({ context }) => {
                 fetch: {
                     ...context.meta.fetch,
                     categories: [...(context.meta.fetch.categories || []), "deprecated"],
+                    deprecation: {
+                        message: "This command is deprecated and will be removed soon. Use `curl` instead. Learn more: https://docs.zapier.com/sdk/cli-reference#curl",
+                    },
                 },
             },
         },

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

@@ -67,6 +67,16 @@ async function promptConfirm(confirmType) {
     ]);
     return { confirmed, messageAfter };
 }
+function emitDeprecationWarning({ cliCommandName, deprecation, }) {
+    if (!deprecation) {
+        return;
+    }
+    console.warn();
+    console.warn(chalk.yellow.bold("⚠️  DEPRECATION WARNING") +
+        chalk.yellow(` - \`${cliCommandName}\` is deprecated.`));
+    console.warn(chalk.yellow(`   ${deprecation.message}`));
+    console.warn();
+}
 // ============================================================================
 // Schema Analysis
 // ============================================================================
@@ -342,6 +352,10 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
             // The last argument is always the command object with parsed options
             const commandObj = args[args.length - 1];
             const options = commandObj.opts();
+            emitDeprecationWarning({
+                cliCommandName,
+                deprecation: functionInfo.deprecation,
+            });
             // Check if this is a list command for pagination
             const isListCommand = functionInfo.type === "list";
             const hasPaginationParams = parameters.some((p) => p.name === "maxItems" || p.name === "pageSize");

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { ZapierSdk } from "@zapier/zapier-sdk";
+import { type ZapierSdk } from "@zapier/zapier-sdk";
 export declare class SchemaParameterResolver {
     resolveParameters(schema: z.ZodSchema, providedParams: unknown, sdk: ZapierSdk, functionName?: string): Promise<unknown>;
     private extractParametersFromSchema;

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

@@ -1,6 +1,7 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { z } from "zod";
+import { runWithTelemetryContext, } from "@zapier/zapier-sdk";
 import { ZapierCliUserCancellationError } from "./errors";
 // ============================================================================
 // Local Resolution Helper Functions
@@ -50,146 +51,114 @@ function getLocalResolutionOrderForParams(paramNames, resolvers) {
 // ============================================================================
 export class SchemaParameterResolver {
     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) => 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;
-            return !hasValue;
-        });
-        // Determine parameter resolution categories:
-        // - functionally required: must be provided (inputs)
-        // - always prompt: should be prompted for but can be skipped (connectionId)
-        // - truly optional: only ask if user wants to be prompted
-        const functionallyRequired = missingResolvable.filter((param) => {
-            // Schema-required parameters are always functionally required
-            if (param.isRequired)
-                return true;
-            // Only inputs is functionally required for run-action
-            if (param.name === "inputs") {
-                return true;
-            }
-            return false;
-        });
-        // Parameters that should always be prompted for directly, but can be skipped
-        const alwaysPrompt = missingResolvable.filter((param) => {
-            if (functionallyRequired.includes(param))
-                return false;
-            // connectionId should always be prompted for (since it's usually needed)
-            // but can be skipped with "Continue without connection"
-            if (param.name === "connectionId") {
-                return true;
-            }
-            return false;
-        });
-        const trulyOptional = missingResolvable.filter((param) => !functionallyRequired.includes(param) && !alwaysPrompt.includes(param));
-        if (parseResult.success &&
-            functionallyRequired.length === 0 &&
-            alwaysPrompt.length === 0) {
-            return parseResult.data;
-        }
-        if (functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
-            // No functionally required parameters missing, but check if we can parse
-            if (!parseResult.success) {
-                throw parseResult.error;
-            }
-            return parseResult.data;
-        }
-        // 2. Resolve functionally required parameters first
-        const resolvedParams = { ...providedParams };
-        const context = {
-            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 = getLocalResolutionOrderForParams(requiredParamNames, localResolvers);
-            // Find all parameters that need to be resolved (including dependencies)
-            // from the available resolvable parameters
-            const orderedRequiredParams = requiredResolutionOrder
-                .map((paramName) => {
-                // First try to find in functionally required
-                let param = functionallyRequired.find((p) => p.name === paramName);
-                // If not found, try always prompt (for dependencies like connectionId)
-                if (!param) {
-                    param = alwaysPrompt.find((p) => p.name === paramName);
-                }
-                // If not found, try truly optional (for other dependencies)
-                if (!param) {
-                    param = trulyOptional.find((p) => p.name === paramName);
-                }
-                return param;
-            })
-                .filter((param) => param !== undefined);
-            for (const param of orderedRequiredParams) {
-                try {
-                    const value = await this.resolveParameter(param, context, functionName);
-                    this.setNestedValue(resolvedParams, param.path, value);
-                    // Update context with newly resolved value
-                    context.resolvedParams = resolvedParams;
+        return runWithTelemetryContext(async () => {
+            // 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) => 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;
+                return !hasValue;
+            });
+            // Determine parameter resolution categories:
+            // - functionally required: must be provided (inputs)
+            // - always prompt: should be prompted for but can be skipped (connectionId)
+            // - truly optional: only ask if user wants to be prompted
+            const functionallyRequired = missingResolvable.filter((param) => {
+                // Schema-required parameters are always functionally required
+                if (param.isRequired)
+                    return true;
+                // Only inputs is functionally required for run-action
+                if (param.name === "inputs") {
+                    return true;
                 }
-                catch (error) {
-                    if (this.isUserCancellation(error)) {
-                        console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                        throw new ZapierCliUserCancellationError();
-                    }
-                    throw error;
+                return false;
+            });
+            // Parameters that should always be prompted for directly, but can be skipped
+            const alwaysPrompt = missingResolvable.filter((param) => {
+                if (functionallyRequired.includes(param))
+                    return false;
+                // connectionId should always be prompted for (since it's usually needed)
+                // but can be skipped with "Continue without connection"
+                if (param.name === "connectionId") {
+                    return true;
                 }
+                return false;
+            });
+            const trulyOptional = missingResolvable.filter((param) => !functionallyRequired.includes(param) &&
+                !alwaysPrompt.includes(param));
+            if (parseResult.success &&
+                functionallyRequired.length === 0 &&
+                alwaysPrompt.length === 0) {
+                return parseResult.data;
             }
-            // Remove resolved dependencies from other categories to avoid double-prompting
-            const resolvedParamNames = new Set(orderedRequiredParams.map((p) => p.name));
-            alwaysPrompt.splice(0, alwaysPrompt.length, ...alwaysPrompt.filter((p) => !resolvedParamNames.has(p.name)));
-            trulyOptional.splice(0, trulyOptional.length, ...trulyOptional.filter((p) => !resolvedParamNames.has(p.name)));
-        }
-        // 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 = 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, functionName);
-                    this.setNestedValue(resolvedParams, param.path, value);
-                    // Update context with newly resolved value
-                    context.resolvedParams = resolvedParams;
+            if (functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
+                // No functionally required parameters missing, but check if we can parse
+                if (!parseResult.success) {
+                    throw parseResult.error;
                 }
-                catch (error) {
-                    if (this.isUserCancellation(error)) {
-                        console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                        throw new ZapierCliUserCancellationError();
+                return parseResult.data;
+            }
+            // 2. Resolve functionally required parameters first
+            const resolvedParams = { ...providedParams };
+            const context = {
+                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 = getLocalResolutionOrderForParams(requiredParamNames, localResolvers);
+                // Find all parameters that need to be resolved (including dependencies)
+                // from the available resolvable parameters
+                const orderedRequiredParams = requiredResolutionOrder
+                    .map((paramName) => {
+                    // First try to find in functionally required
+                    let param = functionallyRequired.find((p) => p.name === paramName);
+                    // If not found, try always prompt (for dependencies like connectionId)
+                    if (!param) {
+                        param = alwaysPrompt.find((p) => p.name === paramName);
+                    }
+                    // If not found, try truly optional (for other dependencies)
+                    if (!param) {
+                        param = trulyOptional.find((p) => p.name === paramName);
+                    }
+                    return param;
+                })
+                    .filter((param) => param !== undefined);
+                for (const param of orderedRequiredParams) {
+                    try {
+                        const value = await this.resolveParameter(param, context, functionName);
+                        this.setNestedValue(resolvedParams, param.path, value);
+                        // Update context with newly resolved value
+                        context.resolvedParams = resolvedParams;
+                    }
+                    catch (error) {
+                        if (this.isUserCancellation(error)) {
+                            console.log(chalk.yellow("\n\nOperation cancelled by user"));
+                            throw new ZapierCliUserCancellationError();
+                        }
+                        throw error;
                     }
-                    throw error;
                 }
+                // Remove resolved dependencies from other categories to avoid double-prompting
+                const resolvedParamNames = new Set(orderedRequiredParams.map((p) => p.name));
+                alwaysPrompt.splice(0, alwaysPrompt.length, ...alwaysPrompt.filter((p) => !resolvedParamNames.has(p.name)));
+                trulyOptional.splice(0, trulyOptional.length, ...trulyOptional.filter((p) => !resolvedParamNames.has(p.name)));
             }
-        }
-        // 4. Ask user if they want to resolve truly optional parameters
-        if (trulyOptional.length > 0) {
-            const optionalNames = trulyOptional.map((p) => p.name).join(", ");
-            const shouldResolveOptional = await inquirer.prompt([
-                {
-                    type: "confirm",
-                    name: "resolveOptional",
-                    message: `Would you like to be prompted for optional parameters (${optionalNames})?`,
-                    default: false,
-                },
-            ]);
-            if (shouldResolveOptional.resolveOptional) {
-                // Resolve optional parameters using their resolvers
-                const optionalParamNames = trulyOptional.map((p) => p.name);
-                const optionalResolutionOrder = getLocalResolutionOrderForParams(optionalParamNames, localResolvers);
-                const orderedOptionalParams = optionalResolutionOrder
-                    .map((paramName) => trulyOptional.find((p) => p.name === paramName))
+            // 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 = getLocalResolutionOrderForParams(alwaysPromptNames, localResolvers);
+                const orderedAlwaysPromptParams = alwaysPromptResolutionOrder
+                    .map((paramName) => alwaysPrompt.find((p) => p.name === paramName))
                     .filter((param) => param !== undefined);
-                for (const param of orderedOptionalParams) {
+                for (const param of orderedAlwaysPromptParams) {
                     try {
                         const value = await this.resolveParameter(param, context, functionName);
                         this.setNestedValue(resolvedParams, param.path, value);
@@ -205,14 +174,49 @@ export class SchemaParameterResolver {
                     }
                 }
             }
-        }
-        // 3. Validate final parameters
-        const finalResult = schema.safeParse(resolvedParams);
-        if (!finalResult.success) {
-            console.error(chalk.red("❌ Parameter validation failed after resolution:"));
-            throw finalResult.error;
-        }
-        return finalResult.data;
+            // 4. Ask user if they want to resolve truly optional parameters
+            if (trulyOptional.length > 0) {
+                const optionalNames = trulyOptional.map((p) => p.name).join(", ");
+                const shouldResolveOptional = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "resolveOptional",
+                        message: `Would you like to be prompted for optional parameters (${optionalNames})?`,
+                        default: false,
+                    },
+                ]);
+                if (shouldResolveOptional.resolveOptional) {
+                    // Resolve optional parameters using their resolvers
+                    const optionalParamNames = trulyOptional.map((p) => p.name);
+                    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, functionName);
+                            this.setNestedValue(resolvedParams, param.path, value);
+                            // Update context with newly resolved value
+                            context.resolvedParams = resolvedParams;
+                        }
+                        catch (error) {
+                            if (this.isUserCancellation(error)) {
+                                console.log(chalk.yellow("\n\nOperation cancelled by user"));
+                                throw new ZapierCliUserCancellationError();
+                            }
+                            throw error;
+                        }
+                    }
+                }
+            }
+            // 5. Validate final parameters
+            const finalResult = schema.safeParse(resolvedParams);
+            if (!finalResult.success) {
+                console.error(chalk.red("❌ Parameter validation failed after resolution:"));
+                throw finalResult.error;
+            }
+            return finalResult.data;
+        });
     }
     extractParametersFromSchema(schema) {
         const parameters = [];