@zapier/zapier-sdk-cli 0.15.14 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @zapier/zapier-sdk-cli
 
+## 0.16.0
+
+### Minor Changes
+
+- 24ae4f0: Upgrade to Zod 4
+  - Update all packages to use Zod 4
+  - Migrate internal API access from `_def` to `_zod.def`
+  - Update `z.record()` calls to include explicit key types
+  - Fix schema introspection for documentation generation and CLI
+  - Update MCP schema converter for Zod 4 structure
+
+### Patch Changes
+
+- Updated dependencies [24ae4f0]
+  - @zapier/zapier-sdk-mcp@0.4.0
+  - @zapier/zapier-sdk@0.16.0
+
 ## 0.15.14
 
 ### Patch Changes

package/dist/cli.cjs

@@ -293,11 +293,11 @@ var SchemaParameterResolver = class {
     let isRequired = true;
     if (baseSchema instanceof zod.z.ZodOptional) {
       isRequired = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     }
     if (baseSchema instanceof zod.z.ZodDefault) {
       isRequired = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     }
     return this.createResolvableParameter([fieldName], baseSchema, isRequired);
   }
@@ -786,10 +786,10 @@ Optional fields${pathContext}:`));
   }
 };
 function getFormatMetadata(schema) {
-  return schema?._def?.formatMeta;
+  return schema?._zod?.def?.formatMeta;
 }
 function getOutputSchema(schema) {
-  return schema?._def?.outputSchema;
+  return schema?._zod?.def?.outputSchema;
 }
 function formatJsonOutput(data) {
   if (data === void 0) {
@@ -878,9 +878,9 @@ function formatItemsGeneric(items, startingNumber = 0) {
 }
 function analyzeZodSchema(schema, functionInfo) {
   const parameters = [];
-  if (schema._def && schema._def.typeName === "ZodEffects") {
-    const innerSchema = schema._def.schema;
-    return analyzeZodSchema(innerSchema, functionInfo);
+  const schemaDef = schema._zod?.def;
+  if (schemaDef?.type === "effect" && schemaDef.innerType) {
+    return analyzeZodSchema(schemaDef.innerType, functionInfo);
   }
   if (schema instanceof zod.z.ZodObject) {
     const shape = schema.shape;
@@ -904,14 +904,17 @@ function analyzeZodField(name, schema, functionInfo) {
   while (true) {
     if (baseSchema instanceof zod.z.ZodOptional) {
       required = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     } else if (baseSchema instanceof zod.z.ZodDefault) {
       required = false;
-      defaultValue = baseSchema._def.defaultValue();
-      baseSchema = baseSchema._def.innerType;
-    } else if (baseSchema._def && baseSchema._def.typeName === "ZodNullable") {
-      baseSchema = baseSchema._def.innerType;
+      defaultValue = baseSchema._zod.def.defaultValue();
+      baseSchema = baseSchema._zod.def.innerType;
     } else {
+      const zodDef = baseSchema._zod?.def;
+      if (zodDef?.typeName === "ZodNullable" && zodDef.innerType) {
+        baseSchema = zodDef.innerType;
+        continue;
+      }
       break;
     }
   }
@@ -927,7 +930,7 @@ function analyzeZodField(name, schema, functionInfo) {
     paramType = "array";
   } else if (baseSchema instanceof zod.z.ZodEnum) {
     paramType = "string";
-    choices = baseSchema._def.values;
+    choices = baseSchema.options;
   } else if (baseSchema instanceof zod.z.ZodRecord) {
     paramType = "string";
   }
@@ -1625,7 +1628,7 @@ var LoginSchema = zod.z.object({
 
 // package.json
 var package_default = {
-  version: "0.15.14"};
+  version: "0.16.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -2904,7 +2907,7 @@ function createZapierCliSdk(options = {}) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.15.14"};
+  version: "0.16.0"};
 function detectPackageManager(cwd = process.cwd()) {
   const ua = process.env.npm_config_user_agent;
   if (ua) {

package/dist/cli.mjs

@@ -257,11 +257,11 @@ var SchemaParameterResolver = class {
     let isRequired = true;
     if (baseSchema instanceof z.ZodOptional) {
       isRequired = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     }
     if (baseSchema instanceof z.ZodDefault) {
       isRequired = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     }
     return this.createResolvableParameter([fieldName], baseSchema, isRequired);
   }
@@ -750,10 +750,10 @@ Optional fields${pathContext}:`));
   }
 };
 function getFormatMetadata(schema) {
-  return schema?._def?.formatMeta;
+  return schema?._zod?.def?.formatMeta;
 }
 function getOutputSchema(schema) {
-  return schema?._def?.outputSchema;
+  return schema?._zod?.def?.outputSchema;
 }
 function formatJsonOutput(data) {
   if (data === void 0) {
@@ -842,9 +842,9 @@ function formatItemsGeneric(items, startingNumber = 0) {
 }
 function analyzeZodSchema(schema, functionInfo) {
   const parameters = [];
-  if (schema._def && schema._def.typeName === "ZodEffects") {
-    const innerSchema = schema._def.schema;
-    return analyzeZodSchema(innerSchema, functionInfo);
+  const schemaDef = schema._zod?.def;
+  if (schemaDef?.type === "effect" && schemaDef.innerType) {
+    return analyzeZodSchema(schemaDef.innerType, functionInfo);
   }
   if (schema instanceof z.ZodObject) {
     const shape = schema.shape;
@@ -868,14 +868,17 @@ function analyzeZodField(name, schema, functionInfo) {
   while (true) {
     if (baseSchema instanceof z.ZodOptional) {
       required = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     } else if (baseSchema instanceof z.ZodDefault) {
       required = false;
-      defaultValue = baseSchema._def.defaultValue();
-      baseSchema = baseSchema._def.innerType;
-    } else if (baseSchema._def && baseSchema._def.typeName === "ZodNullable") {
-      baseSchema = baseSchema._def.innerType;
+      defaultValue = baseSchema._zod.def.defaultValue();
+      baseSchema = baseSchema._zod.def.innerType;
     } else {
+      const zodDef = baseSchema._zod?.def;
+      if (zodDef?.typeName === "ZodNullable" && zodDef.innerType) {
+        baseSchema = zodDef.innerType;
+        continue;
+      }
       break;
     }
   }
@@ -891,7 +894,7 @@ function analyzeZodField(name, schema, functionInfo) {
     paramType = "array";
   } else if (baseSchema instanceof z.ZodEnum) {
     paramType = "string";
-    choices = baseSchema._def.values;
+    choices = baseSchema.options;
   } else if (baseSchema instanceof z.ZodRecord) {
     paramType = "string";
   }
@@ -1589,7 +1592,7 @@ var LoginSchema = z.object({
 
 // package.json
 var package_default = {
-  version: "0.15.14"};
+  version: "0.16.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -2868,7 +2871,7 @@ function createZapierCliSdk(options = {}) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.15.14"};
+  version: "0.16.0"};
 function detectPackageManager(cwd = process.cwd()) {
   const ua = process.env.npm_config_user_agent;
   if (ua) {

package/dist/index.cjs

@@ -291,7 +291,7 @@ var LoginSchema = zod.z.object({
 
 // package.json
 var package_default = {
-  version: "0.15.14"};
+  version: "0.16.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {

package/dist/index.d.mts

@@ -2,18 +2,10 @@ import { AppItem, Manifest, GetSdkType, ZapierSdk, ZapierSdkOptions, BaseEvent }
 import { z } from 'zod';
 
 declare const BuildManifestSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
+    appKeys: z.ZodArray<z.ZodString>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     configPath: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 type BuildManifestOptions = z.infer<typeof BuildManifestSchema> & {
     onProgress?: (event: ManifestBuildProgressEvent) => void;
 };
@@ -64,21 +56,11 @@ interface BuildManifestPluginProvides {
 }
 
 declare const GenerateAppTypesSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
-    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    appKeys: z.ZodArray<z.ZodString>;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     typesOutputDirectory: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}>;
+}, z.core.$strip>;
 type GenerateAppTypesOptions = z.infer<typeof GenerateAppTypesSchema> & {
     onProgress?: (event: AppTypesProgressEvent) => void;
 };

package/dist/index.d.ts

@@ -2,18 +2,10 @@ import { AppItem, Manifest, GetSdkType, ZapierSdk, ZapierSdkOptions, BaseEvent }
 import { z } from 'zod';
 
 declare const BuildManifestSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
+    appKeys: z.ZodArray<z.ZodString>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     configPath: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 type BuildManifestOptions = z.infer<typeof BuildManifestSchema> & {
     onProgress?: (event: ManifestBuildProgressEvent) => void;
 };
@@ -64,21 +56,11 @@ interface BuildManifestPluginProvides {
 }
 
 declare const GenerateAppTypesSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
-    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    appKeys: z.ZodArray<z.ZodString>;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     typesOutputDirectory: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}>;
+}, z.core.$strip>;
 type GenerateAppTypesOptions = z.infer<typeof GenerateAppTypesSchema> & {
     onProgress?: (event: AppTypesProgressEvent) => void;
 };

package/dist/index.mjs

@@ -260,7 +260,7 @@ var LoginSchema = z.object({
 
 // package.json
 var package_default = {
-  version: "0.15.14"};
+  version: "0.16.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zapier/zapier-sdk-cli",
-    "version": "0.15.14",
+    "version": "0.16.0",
     "description": "Command line interface for Zapier SDK",
     "main": "dist/index.cjs",
     "module": "dist/index.mjs",
@@ -58,7 +58,7 @@
         "pkce-challenge": "^5.0.0",
         "semver": "^7.7.3",
         "typescript": "^5.8.3",
-        "zod": "^3.25.67"
+        "zod": "4.2.1"
     },
     "devDependencies": {
         "@types/express": "^5.0.3",

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

@@ -1,18 +1,8 @@
 import { z } from "zod";
 export declare const AddSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
-    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    appKeys: z.ZodArray<z.ZodString>;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     configPath: z.ZodOptional<z.ZodString>;
     typesOutput: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    configPath?: string | undefined;
-    typesOutput?: string | undefined;
-}, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    configPath?: string | undefined;
-    typesOutput?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type AddOptions = z.infer<typeof AddSchema>;

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

@@ -1,18 +1,10 @@
 import { z } from "zod";
 import type { AppItem, Manifest } from "@zapier/zapier-sdk";
 export declare const BuildManifestSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
+    appKeys: z.ZodArray<z.ZodString>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     configPath: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type BuildManifestOptions = z.infer<typeof BuildManifestSchema> & {
     onProgress?: (event: ManifestBuildProgressEvent) => void;
 };

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

@@ -6,19 +6,5 @@ export declare const BundleCodeSchema: z.ZodObject<{
     minify: z.ZodOptional<z.ZodBoolean>;
     target: z.ZodOptional<z.ZodString>;
     cjs: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    input: string;
-    string?: boolean | undefined;
-    output?: string | undefined;
-    minify?: boolean | undefined;
-    target?: string | undefined;
-    cjs?: boolean | undefined;
-}, {
-    input: string;
-    string?: boolean | undefined;
-    output?: string | undefined;
-    minify?: boolean | undefined;
-    target?: string | undefined;
-    cjs?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type BundleCodeOptions = z.infer<typeof BundleCodeSchema>;

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

@@ -1,21 +1,11 @@
 import { z } from "zod";
 import type { AppItem } from "@zapier/zapier-sdk";
 export declare const GenerateAppTypesSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
-    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    appKeys: z.ZodArray<z.ZodString>;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     typesOutputDirectory: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type GenerateAppTypesOptions = z.infer<typeof GenerateAppTypesSchema> & {
     onProgress?: (event: AppTypesProgressEvent) => void;
 };

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

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

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

@@ -1,9 +1,5 @@
 import { z } from "zod";
 export declare const LoginSchema: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    timeout?: string | undefined;
-}, {
-    timeout?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type LoginOptions = z.infer<typeof LoginSchema>;

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

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

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

@@ -1,9 +1,5 @@
 import { z } from "zod";
 export declare const McpSchema: z.ZodObject<{
     port: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    port?: string | undefined;
-}, {
-    port?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type McpOptions = z.infer<typeof McpSchema>;

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

@@ -23,12 +23,12 @@ function analyzeZodField(name, schema, functionInfo) {
     // Unwrap optional and default wrappers
     if (baseSchema instanceof z.ZodOptional) {
         required = false;
-        baseSchema = baseSchema._def.innerType;
+        baseSchema = baseSchema._zod.def.innerType;
     }
     if (baseSchema instanceof z.ZodDefault) {
         required = false;
-        defaultValue = baseSchema._def.defaultValue();
-        baseSchema = baseSchema._def.innerType;
+        defaultValue = baseSchema._zod.def.defaultValue();
+        baseSchema = baseSchema._zod.def.innerType;
     }
     // Determine parameter type
     let paramType = "string";
@@ -47,7 +47,7 @@ function analyzeZodField(name, schema, functionInfo) {
     }
     else if (baseSchema instanceof z.ZodEnum) {
         paramType = "string";
-        choices = baseSchema._def.values;
+        choices = baseSchema.options;
     }
     else if (baseSchema instanceof z.ZodRecord) {
         // Handle Record<string, any> as JSON string input

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

@@ -11,13 +11,10 @@ import { ZapierCliError, ZapierCliExitError } from "./errors";
 function analyzeZodSchema(schema, functionInfo) {
     const parameters = [];
     // Handle ZodEffects (schemas with .refine(), .transform(), etc.)
-    if (schema._def &&
-        schema._def.typeName ===
-            "ZodEffects") {
-        // Get the underlying schema
-        const innerSchema = schema
-            ._def.schema;
-        return analyzeZodSchema(innerSchema, functionInfo);
+    // In Zod, effects have type "effect" and inner schema is accessed via innerType
+    const schemaDef = schema._zod?.def;
+    if (schemaDef?.type === "effect" && schemaDef.innerType) {
+        return analyzeZodSchema(schemaDef.innerType, functionInfo);
     }
     if (schema instanceof z.ZodObject) {
         const shape = schema.shape;
@@ -38,21 +35,22 @@ function analyzeZodField(name, schema, functionInfo) {
     while (true) {
         if (baseSchema instanceof z.ZodOptional) {
             required = false;
-            baseSchema = baseSchema._def.innerType;
+            baseSchema = baseSchema._zod.def.innerType;
         }
         else if (baseSchema instanceof z.ZodDefault) {
             required = false;
-            defaultValue = baseSchema._def.defaultValue();
-            baseSchema = baseSchema._def.innerType;
-        }
-        else if (baseSchema._def &&
-            baseSchema._def
-                .typeName === "ZodNullable") {
-            // nullable doesn't affect CLI required status, but we need to unwrap it to get the base type
-            baseSchema = baseSchema._def.innerType;
+            defaultValue = baseSchema._zod.def.defaultValue();
+            baseSchema = baseSchema._zod.def.innerType;
         }
         else {
-            break; // No more wrappers to unwrap
+            // Check for ZodNullable - nullable doesn't affect CLI required status, but we need to unwrap it to get the base type
+            const zodDef = baseSchema._zod?.def;
+            if (zodDef?.typeName === "ZodNullable" && zodDef.innerType) {
+                baseSchema = zodDef.innerType;
+                continue;
+            }
+            // No more wrappers to unwrap
+            break;
         }
     }
     // Determine parameter type
@@ -72,7 +70,7 @@ function analyzeZodField(name, schema, functionInfo) {
     }
     else if (baseSchema instanceof z.ZodEnum) {
         paramType = "string";
-        choices = baseSchema._def.values;
+        choices = baseSchema.options;
     }
     else if (baseSchema instanceof z.ZodRecord) {
         // Handle Record<string, any> as JSON string input

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

@@ -234,11 +234,11 @@ export class SchemaParameterResolver {
         // Check if field is optional or has default
         if (baseSchema instanceof z.ZodOptional) {
             isRequired = false;
-            baseSchema = baseSchema._def.innerType;
+            baseSchema = baseSchema._zod.def.innerType;
         }
         if (baseSchema instanceof z.ZodDefault) {
             isRequired = false;
-            baseSchema = baseSchema._def.innerType;
+            baseSchema = baseSchema._zod.def.innerType;
         }
         return this.createResolvableParameter([fieldName], baseSchema, isRequired);
     }

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

@@ -3,11 +3,12 @@ import util from "util";
 // These functions are internal to SDK, implementing basic formatting fallback
 // TODO: Consider exposing these utilities or implementing proper CLI formatting
 function getFormatMetadata(schema) {
-    return schema?._def
-        ?.formatMeta;
+    return schema?._zod
+        ?.def?.formatMeta;
 }
 function getOutputSchema(schema) {
-    return schema?._def?.outputSchema;
+    return schema?._zod?.def
+        ?.outputSchema;
 }
 // ============================================================================
 // JSON Formatting