@zapier/zapier-sdk-cli 0.38.1 → 0.39.0

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

@@ -7,14 +7,14 @@ import { join, resolve } from "path";
 import { detectTypesOutputDirectory } from "../../utils/directory-detection";
 export const generateAppTypesPlugin = ({ sdk }) => {
     const generateAppTypes = createFunction(async function generateAppTypes(options) {
-        const { appKeys, connectionIds, skipWrite = false, typesOutputDirectory = await detectTypesOutputDirectory(), onProgress, } = options;
+        const { apps: appKeys, connections: connectionIds, skipWrite = false, typesOutputDirectory = await detectTypesOutputDirectory(), onProgress, } = options;
         const resolvedTypesOutput = resolve(typesOutputDirectory);
         const result = {
             typeDefinitions: {},
         };
         // Get apps using listApps (which respects existing manifest for version locking)
         onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
-        const appsIterable = sdk.listApps({ appKeys }).items();
+        const appsIterable = sdk.listApps({ apps: appKeys }).items();
         const apps = [];
         for await (const app of appsIterable) {
             apps.push(app);
@@ -32,7 +32,7 @@ export const generateAppTypesPlugin = ({ sdk }) => {
                 count: connectionIds.length,
             });
             const connectionsIterable = sdk
-                .listConnections({ connectionIds })
+                .listConnections({ connections: connectionIds })
                 .items();
             for await (const connection of connectionsIterable) {
                 connections.push(connection);
@@ -54,7 +54,7 @@ export const generateAppTypesPlugin = ({ sdk }) => {
         for (const app of apps) {
             onProgress?.({
                 type: "app_processing_start",
-                appKey: app.key,
+                app: app.key,
                 slug: app.slug,
             });
             try {
@@ -62,7 +62,7 @@ export const generateAppTypesPlugin = ({ sdk }) => {
                     const errorMessage = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
                     onProgress?.({
                         type: "app_processing_error",
-                        appKey: app.key,
+                        app: app.key,
                         error: errorMessage,
                     });
                     throw new ZapierValidationError(errorMessage, {
@@ -82,7 +82,7 @@ export const generateAppTypesPlugin = ({ sdk }) => {
                         connectionId = matchingConnection.id;
                         onProgress?.({
                             type: "connection_matched",
-                            appKey: app.key,
+                            app: app.key,
                             connectionId: matchingConnection.id,
                             connectionTitle: matchingConnection.title || "",
                         });
@@ -90,7 +90,7 @@ export const generateAppTypesPlugin = ({ sdk }) => {
                     else {
                         onProgress?.({
                             type: "connection_not_matched",
-                            appKey: app.key,
+                            app: app.key,
                         });
                     }
                 }
@@ -121,14 +121,14 @@ export const generateAppTypesPlugin = ({ sdk }) => {
                 }
                 onProgress?.({
                     type: "app_processing_complete",
-                    appKey: app.key,
+                    app: app.key,
                 });
             }
             catch (error) {
                 const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
                 onProgress?.({
                     type: "app_processing_error",
-                    appKey: app.key,
+                    app: app.key,
                     error: errorMessage,
                 });
                 if (error instanceof ZapierValidationError) {

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

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import type { AppItem } from "@zapier/zapier-sdk";
 export declare const GenerateAppTypesSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString>;
-    connectionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    apps: z.ZodArray<z.ZodString>;
+    connections: z.ZodOptional<z.ZodArray<z.ZodString>>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     typesOutputDirectory: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
@@ -26,16 +26,16 @@ export type AppTypesProgressEvent = {
     count: number;
 } | {
     type: "app_processing_start";
-    appKey: string;
+    app: string;
     slug?: string;
 } | {
     type: "connection_matched";
-    appKey: string;
+    app: string;
     connectionId: string;
     connectionTitle: string;
 } | {
     type: "connection_not_matched";
-    appKey: string;
+    app: string;
 } | {
     type: "type_generated";
     manifestKey: string;
@@ -46,10 +46,10 @@ export type AppTypesProgressEvent = {
     filePath: string;
 } | {
     type: "app_processing_complete";
-    appKey: string;
+    app: string;
 } | {
     type: "app_processing_error";
-    appKey: string;
+    app: string;
     error: string;
 };
 export interface GenerateAppTypesResult {

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

@@ -1,11 +1,11 @@
 import { z } from "zod";
 export const GenerateAppTypesSchema = z
     .object({
-    appKeys: z
+    apps: z
         .array(z.string().min(1, "App key cannot be empty"))
         .min(1, "At least one app key is required")
         .describe("One or more app keys to generate types for (e.g., 'slack', 'github', 'trello')"),
-    connectionIds: z
+    connections: z
         .array(z.string())
         .optional()
         .describe("Connection IDs to use for type generation (e.g., ['123', '456'])"),

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

@@ -1,4 +1,4 @@
-import type { Command } from "commander";
+import { type Command } from "commander";
 import type { ZapierSdk } from "@zapier/zapier-sdk";
 export declare function sanitizeCliArguments(args: string[]): string[];
 export declare function generateCliCommands(program: Command, sdk: ZapierSdk): void;

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

@@ -1,3 +1,4 @@
+import { Option } from "commander";
 import { z } from "zod";
 import { isPositional } from "@zapier/zapier-sdk";
 import { SchemaParameterResolver } from "./parameter-resolver";
@@ -164,15 +165,17 @@ function analyzeZodSchema(schema, functionInfo) {
     return parameters;
 }
 function analyzeZodField(name, schema, functionInfo) {
-    // Filter out deprecated parameters
-    if (functionInfo?.deprecatedParameters?.includes(name)) {
-        return null;
-    }
     let baseSchema = schema;
     let required = true;
     let defaultValue = undefined;
-    // Unwrap optional, default, and nullable wrappers - keep unwrapping until we get to the base type
+    let isDeprecated = false;
+    // Unwrap optional, default, and nullable wrappers - keep unwrapping until we get to the base type.
+    // Check .meta()?.deprecated at each level since it doesn't propagate through wrappers.
     while (true) {
+        const meta = baseSchema.meta?.();
+        if (meta?.deprecated) {
+            isDeprecated = true;
+        }
         if (baseSchema instanceof z.ZodOptional) {
             required = false;
             baseSchema = baseSchema._zod.def.innerType;
@@ -247,6 +250,7 @@ function analyzeZodField(name, schema, functionInfo) {
         hasResolver: paramHasResolver,
         isPositional: isPositional(schema),
         elementType,
+        hidden: isDeprecated,
     };
 }
 /**
@@ -267,10 +271,6 @@ function analyzeInputParameters(inputParameters, functionInfo) {
             // Flatten object properties into individual CLI flags
             const shape = schema.shape;
             for (const [key, fieldSchema] of Object.entries(shape)) {
-                // Skip deprecated parameters
-                if (functionInfo?.deprecatedParameters?.includes(key)) {
-                    continue;
-                }
                 const analyzed = analyzeZodField(key, fieldSchema, functionInfo);
                 if (analyzed) {
                     if (isOptional) {
@@ -443,6 +443,16 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
                 hasUserSpecifiedMaxItems,
             });
             const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
+            // Remap aliased parameter names (e.g., authenticationId → connectionId)
+            const schemaAliases = schema?.meta?.()?.aliases;
+            if (schemaAliases) {
+                for (const [oldName, newName] of Object.entries(schemaAliases)) {
+                    if (oldName in rawParams && !(newName in rawParams)) {
+                        rawParams[newName] = rawParams[oldName];
+                        delete rawParams[oldName];
+                    }
+                }
+            }
             if (schema && !usesInputParameters) {
                 const resolver = new SchemaParameterResolver();
                 resolvedParams = (await resolver.resolveParameters(schema, rawParams, sdk, functionInfo.name, {
@@ -557,7 +567,7 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
                         cli_arguments: sanitizeCliArguments(process.argv.slice(2)),
                     },
                     context: {
-                        selected_api: resolvedParams.appKey ?? null,
+                        selected_api: resolvedParams.app ?? null,
                     },
                 });
                 sdk
@@ -627,16 +637,30 @@ function addCommand(program, commandName, config) {
             }
             flags.push(`--${kebabName}`);
             if (param.type === "boolean") {
-                command.option(flags.join(", "), param.description);
+                const opt = new Option(flags.join(", "), param.description);
+                if (param.hidden)
+                    opt.hideHelp();
+                command.addOption(opt);
             }
             else if (param.type === "array") {
                 // For arrays, use collect pattern for repeatable flags (e.g., -d foo -d bar)
                 const flagSignature = flags.join(", ") + ` <value>`;
-                command.option(flagSignature, param.description || "", collect, []);
+                const opt = new Option(flagSignature, param.description || "");
+                opt.default([]);
+                opt.argParser((value, previous) => (previous || []).concat([value]));
+                if (param.hidden)
+                    opt.hideHelp();
+                command.addOption(opt);
             }
             else {
                 const flagSignature = flags.join(", ") + ` <${param.type}>`;
-                command.option(flagSignature, param.description || "", param.default);
+                const opt = new Option(flagSignature, param.description || "");
+                if (param.default !== undefined) {
+                    opt.default(param.default);
+                }
+                if (param.hidden)
+                    opt.hideHelp();
+                command.addOption(opt);
             }
         }
     });

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

@@ -709,11 +709,11 @@ export class SchemaParameterResolver {
                 : `Fetching choices for ${fieldMeta.title}`);
             this.startSpinner();
             const page = await context.sdk.listInputFieldChoices({
-                appKey: context.resolvedParams.appKey,
-                actionKey: context.resolvedParams.actionKey,
+                app: context.resolvedParams.app,
+                action: context.resolvedParams.action,
                 actionType: context.resolvedParams.actionType,
-                connectionId: context.resolvedParams.connectionId,
-                inputFieldKey: fieldMeta.key,
+                connection: context.resolvedParams.connection,
+                inputField: fieldMeta.key,
                 inputs,
                 ...(cursor && { cursor }),
             });