@zapier/zapier-sdk-cli 0.34.10 → 0.34.12

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @zapier/zapier-sdk-cli
 
+## 0.34.12
+
+### Patch Changes
+
+- d9e0f1d: Fix user properties being overwritten by context merge in telemetry events
+- Updated dependencies [d9e0f1d]
+  - @zapier/zapier-sdk@0.33.4
+  - @zapier/zapier-sdk-mcp@0.9.21
+
+## 0.34.11
+
+### Patch Changes
+
+- f676852: Suppress resolver method calls from emitting telemetry events
+- Updated dependencies [f676852]
+  - @zapier/zapier-sdk@0.33.3
+  - @zapier/zapier-sdk-mcp@0.9.20
+
 ## 0.34.10
 
 ### Patch Changes

package/dist/cli.cjs

@@ -119,139 +119,105 @@ function getLocalResolutionOrderForParams(paramNames, resolvers) {
 }
 var SchemaParameterResolver = class {
   async resolveParameters(schema, providedParams, sdk2, functionName) {
-    const parseResult = schema.safeParse(providedParams);
-    const allParams = this.extractParametersFromSchema(schema);
-    const resolvableParams = allParams.filter(
-      (param) => this.hasResolver(param.name, sdk2, functionName)
-    );
-    const missingResolvable = resolvableParams.filter((param) => {
-      const hasValue = this.getNestedValue(providedParams, param.path) !== void 0;
-      return !hasValue;
-    });
-    const functionallyRequired = missingResolvable.filter((param) => {
-      if (param.isRequired) return true;
-      if (param.name === "inputs") {
-        return true;
-      }
-      return false;
-    });
-    const alwaysPrompt = missingResolvable.filter((param) => {
-      if (functionallyRequired.includes(param)) return false;
-      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) {
-      if (!parseResult.success) {
-        throw parseResult.error;
-      }
-      return parseResult.data;
-    }
-    const resolvedParams = { ...providedParams };
-    const context = {
-      sdk: sdk2,
-      currentParams: providedParams,
-      resolvedParams,
-      functionName
-    };
-    const localResolvers = this.getLocalResolvers(sdk2, functionName);
-    if (functionallyRequired.length > 0) {
-      const requiredParamNames = functionallyRequired.map((p) => p.name);
-      const requiredResolutionOrder = getLocalResolutionOrderForParams(
-        requiredParamNames,
-        localResolvers
+    return zapierSdk.runWithTelemetryContext(async () => {
+      const parseResult = schema.safeParse(providedParams);
+      const allParams = this.extractParametersFromSchema(schema);
+      const resolvableParams = allParams.filter(
+        (param) => this.hasResolver(param.name, sdk2, functionName)
       );
-      const orderedRequiredParams = requiredResolutionOrder.map((paramName) => {
-        let param = functionallyRequired.find((p) => p.name === paramName);
-        if (!param) {
-          param = alwaysPrompt.find((p) => p.name === paramName);
+      const missingResolvable = resolvableParams.filter((param) => {
+        const hasValue = this.getNestedValue(providedParams, param.path) !== void 0;
+        return !hasValue;
+      });
+      const functionallyRequired = missingResolvable.filter((param) => {
+        if (param.isRequired) return true;
+        if (param.name === "inputs") {
+          return true;
         }
-        if (!param) {
-          param = trulyOptional.find((p) => p.name === paramName);
+        return false;
+      });
+      const alwaysPrompt = missingResolvable.filter((param) => {
+        if (functionallyRequired.includes(param)) return false;
+        if (param.name === "connectionId") {
+          return true;
         }
-        return param;
-      }).filter((param) => param !== void 0);
-      for (const param of orderedRequiredParams) {
-        try {
-          const value = await this.resolveParameter(
-            param,
-            context,
-            functionName
-          );
-          this.setNestedValue(resolvedParams, param.path, value);
-          context.resolvedParams = resolvedParams;
-        } catch (error) {
-          if (this.isUserCancellation(error)) {
-            console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
-            throw new ZapierCliUserCancellationError();
-          }
-          throw error;
+        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) {
+        if (!parseResult.success) {
+          throw parseResult.error;
         }
+        return parseResult.data;
       }
-      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))
-      );
-    }
-    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 !== void 0);
-      for (const param of orderedAlwaysPromptParams) {
-        try {
-          const value = await this.resolveParameter(
-            param,
-            context,
-            functionName
-          );
-          this.setNestedValue(resolvedParams, param.path, value);
-          context.resolvedParams = resolvedParams;
-        } catch (error) {
-          if (this.isUserCancellation(error)) {
-            console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
-            throw new ZapierCliUserCancellationError();
+      const resolvedParams = { ...providedParams };
+      const context = {
+        sdk: sdk2,
+        currentParams: providedParams,
+        resolvedParams,
+        functionName
+      };
+      const localResolvers = this.getLocalResolvers(sdk2, functionName);
+      if (functionallyRequired.length > 0) {
+        const requiredParamNames = functionallyRequired.map((p) => p.name);
+        const requiredResolutionOrder = getLocalResolutionOrderForParams(
+          requiredParamNames,
+          localResolvers
+        );
+        const orderedRequiredParams = requiredResolutionOrder.map((paramName) => {
+          let param = functionallyRequired.find((p) => p.name === paramName);
+          if (!param) {
+            param = alwaysPrompt.find((p) => p.name === paramName);
+          }
+          if (!param) {
+            param = trulyOptional.find((p) => p.name === paramName);
+          }
+          return param;
+        }).filter((param) => param !== void 0);
+        for (const param of orderedRequiredParams) {
+          try {
+            const value = await this.resolveParameter(
+              param,
+              context,
+              functionName
+            );
+            this.setNestedValue(resolvedParams, param.path, value);
+            context.resolvedParams = resolvedParams;
+          } catch (error) {
+            if (this.isUserCancellation(error)) {
+              console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
+              throw new ZapierCliUserCancellationError();
+            }
+            throw error;
           }
-          throw error;
         }
+        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))
+        );
       }
-    }
-    if (trulyOptional.length > 0) {
-      const optionalNames = trulyOptional.map((p) => p.name).join(", ");
-      const shouldResolveOptional = await inquirer__default.default.prompt([
-        {
-          type: "confirm",
-          name: "resolveOptional",
-          message: `Would you like to be prompted for optional parameters (${optionalNames})?`,
-          default: false
-        }
-      ]);
-      if (shouldResolveOptional.resolveOptional) {
-        const optionalParamNames = trulyOptional.map((p) => p.name);
-        const optionalResolutionOrder = getLocalResolutionOrderForParams(
-          optionalParamNames,
+      if (alwaysPrompt.length > 0) {
+        const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
+        const alwaysPromptResolutionOrder = getLocalResolutionOrderForParams(
+          alwaysPromptNames,
           localResolvers
         );
-        const orderedOptionalParams = optionalResolutionOrder.map((paramName) => trulyOptional.find((p) => p.name === paramName)).filter((param) => param !== void 0);
-        for (const param of orderedOptionalParams) {
+        const orderedAlwaysPromptParams = alwaysPromptResolutionOrder.map((paramName) => alwaysPrompt.find((p) => p.name === paramName)).filter((param) => param !== void 0);
+        for (const param of orderedAlwaysPromptParams) {
           try {
             const value = await this.resolveParameter(
               param,
@@ -269,15 +235,53 @@ var SchemaParameterResolver = class {
           }
         }
       }
-    }
-    const finalResult = schema.safeParse(resolvedParams);
-    if (!finalResult.success) {
-      console.error(
-        chalk3__default.default.red("\u274C Parameter validation failed after resolution:")
-      );
-      throw finalResult.error;
-    }
-    return finalResult.data;
+      if (trulyOptional.length > 0) {
+        const optionalNames = trulyOptional.map((p) => p.name).join(", ");
+        const shouldResolveOptional = await inquirer__default.default.prompt([
+          {
+            type: "confirm",
+            name: "resolveOptional",
+            message: `Would you like to be prompted for optional parameters (${optionalNames})?`,
+            default: false
+          }
+        ]);
+        if (shouldResolveOptional.resolveOptional) {
+          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 !== void 0
+          );
+          for (const param of orderedOptionalParams) {
+            try {
+              const value = await this.resolveParameter(
+                param,
+                context,
+                functionName
+              );
+              this.setNestedValue(resolvedParams, param.path, value);
+              context.resolvedParams = resolvedParams;
+            } catch (error) {
+              if (this.isUserCancellation(error)) {
+                console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
+                throw new ZapierCliUserCancellationError();
+              }
+              throw error;
+            }
+          }
+        }
+      }
+      const finalResult = schema.safeParse(resolvedParams);
+      if (!finalResult.success) {
+        console.error(
+          chalk3__default.default.red("\u274C Parameter validation failed after resolution:")
+        );
+        throw finalResult.error;
+      }
+      return finalResult.data;
+    });
   }
   extractParametersFromSchema(schema) {
     const parameters = [];
@@ -923,7 +927,7 @@ var SHARED_COMMAND_CLI_OPTIONS = [
 
 // package.json
 var package_default = {
-  version: "0.34.10"};
+  version: "0.34.12"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -2035,9 +2039,10 @@ var loginPlugin = ({
     const user = await cliLogin.getLoggedInUser();
     context.eventEmission.emit(
       "platform.sdk.ApplicationLifecycleEvent",
-      zapierSdk.buildApplicationLifecycleEvent({
-        lifecycle_event_type: "login_success"
-      })
+      zapierSdk.buildApplicationLifecycleEvent(
+        { lifecycle_event_type: "login_success" },
+        { customuser_id: user.customUserId, account_id: user.accountId }
+      )
     );
     console.log(`\u2705 Successfully logged in as ${user.email}`);
   };
@@ -4199,7 +4204,7 @@ function createZapierCliSdk(options = {}) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.34.10"};
+  version: "0.34.12"};
 var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
 var CACHE_RESET_INTERVAL_MS = (() => {
   const { ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS = `${ONE_DAY_MS}` } = process.env;