@zapier/zapier-sdk 0.13.3 → 0.13.5

package/dist/constants.d.ts

@@ -7,4 +7,8 @@
  * Maximum number of items that can be requested per page across all paginated functions
  */
 export declare const MAX_PAGE_LIMIT = 10000;
+/**
+ * Default telemetry endpoint for the Tracking API
+ */
+export declare const TRACKING_API_ENDPOINT = "https://zapier.com/api/v4/tracking/event/";
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc,QAAQ,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,qBAAqB,8CACW,CAAC"}

package/dist/constants.js

@@ -7,3 +7,7 @@
  * Maximum number of items that can be requested per page across all paginated functions
  */
 export const MAX_PAGE_LIMIT = 10000;
+/**
+ * Default telemetry endpoint for the Tracking API
+ */
+export const TRACKING_API_ENDPOINT = "https://zapier.com/api/v4/tracking/event/";

package/dist/index.cjs

@@ -2,6 +2,27 @@
 
 var zod = require('zod');
 var promises = require('timers/promises');
+var os = require('os');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
 
 // src/types/properties.ts
 function withFormatter(schema, formatMeta) {
@@ -34,6 +55,7 @@ function isPositional(schema) {
 
 // src/constants.ts
 var MAX_PAGE_LIMIT = 1e4;
+var TRACKING_API_ENDPOINT = "https://zapier.com/api/v4/tracking/event/";
 
 // src/types/properties.ts
 var AppKeyPropertySchema = withPositional(
@@ -370,7 +392,7 @@ var FetchInitSchema = zod.z.object({
 // src/plugins/fetch/index.ts
 var fetchPlugin = ({ sdk }) => {
   return {
-    fetch: async function fetch(url, init) {
+    fetch: async function fetch2(url, init) {
       const {
         authenticationId,
         callbackUrl,
@@ -1409,9 +1431,10 @@ var actionTypeResolver = {
     const actionsResponse = await sdk.listActions({
       appKey: resolvedParams.appKey
     });
-    const types = [
-      ...new Set(actionsResponse.data.map((action) => action.action_type))
-    ];
+    const actionTypes = actionsResponse.data.map(
+      (action) => action.action_type
+    );
+    const types = [...new Set(actionTypes)];
     return types.map((type) => ({ key: type, name: type }));
   },
   prompt: (types) => ({
@@ -2824,8 +2847,15 @@ var manifestPlugin = (params) => {
     if (!resolvedApp) return null;
     return `${resolvedApp.implementationName}@${resolvedApp.version || "latest"}`;
   };
-  const updateManifestEntry = async (appKey, entry, configPath = DEFAULT_CONFIG_PATH) => {
-    const manifest2 = await readManifestFromFile(configPath) || { apps: {} };
+  const updateManifestEntry = async (options2) => {
+    const {
+      appKey,
+      entry,
+      configPath = DEFAULT_CONFIG_PATH,
+      skipWrite = false,
+      manifest: inputManifest
+    } = options2;
+    const manifest2 = inputManifest || await readManifestFromFile(configPath) || { apps: {} };
     let existingEntry = findManifestEntry({
       appKey,
       manifest: manifest2
@@ -2856,10 +2886,18 @@ var manifestPlugin = (params) => {
         api
       });
     }
-    manifest2.apps[manifestKey] = entry;
-    await writeManifestToFile(manifest2, configPath);
-    resolvedManifest = void 0;
-    return [manifestKey, entry];
+    const updatedManifest = {
+      ...manifest2,
+      apps: {
+        ...manifest2.apps,
+        [manifestKey]: entry
+      }
+    };
+    if (!skipWrite) {
+      await writeManifestToFile(updatedManifest, configPath);
+      resolvedManifest = void 0;
+    }
+    return [manifestKey, entry, updatedManifest];
   };
   return {
     context: {
@@ -3811,6 +3849,401 @@ var listInputFieldChoicesPlugin = ({ context, sdk }) => {
   };
 };
 
+// src/plugins/eventEmission/transport.ts
+var DEFAULT_RETRY_ATTEMPTS = 2;
+var DEFAULT_RETRY_DELAY_MS = 300;
+var HttpTransport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async emit(subject, event) {
+    try {
+      await this.emitWithRetry(
+        subject,
+        event,
+        this.config.retryAttempts || DEFAULT_RETRY_ATTEMPTS
+      );
+    } catch {
+    }
+  }
+  async emitWithRetry(subject, event, attemptsLeft) {
+    try {
+      const payload = {
+        subject,
+        properties: event
+      };
+      const response = await fetch(this.config.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.config.headers
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok && attemptsLeft > 1) {
+        await this.delay(this.config.retryDelayMs || DEFAULT_RETRY_DELAY_MS);
+        return this.emitWithRetry(subject, event, attemptsLeft - 1);
+      }
+    } catch (error) {
+      if (attemptsLeft > 1) {
+        await this.delay(this.config.retryDelayMs || DEFAULT_RETRY_DELAY_MS);
+        return this.emitWithRetry(subject, event, attemptsLeft - 1);
+      }
+      throw error;
+    }
+  }
+  async delay(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+};
+var ConsoleTransport = class {
+  async emit(subject, event) {
+    try {
+      console.log(
+        "[SDK Telemetry]",
+        JSON.stringify({ subject, properties: event }, null, 2)
+      );
+    } catch {
+    }
+  }
+};
+var NoopTransport = class {
+  async emit(_subject, _event) {
+  }
+};
+function createTransport(config) {
+  try {
+    switch (config.type) {
+      case "http":
+        if (!config.endpoint) {
+          throw new Error("HTTP transport requires endpoint");
+        }
+        return new HttpTransport({
+          endpoint: config.endpoint,
+          headers: config.headers,
+          retryAttempts: config.retryAttempts,
+          retryDelayMs: config.retryDelayMs
+        });
+      case "console":
+        return new ConsoleTransport();
+      case "noop":
+      default:
+        return new NoopTransport();
+    }
+  } catch {
+    return new NoopTransport();
+  }
+}
+function generateEventId() {
+  return crypto.randomUUID();
+}
+function getCurrentTimestamp() {
+  return Date.now();
+}
+function getReleaseId() {
+  return process?.env?.SDK_RELEASE_ID || "development";
+}
+function getOsInfo() {
+  try {
+    return {
+      platform: os__namespace.platform() || null,
+      release: os__namespace.release() || null,
+      architecture: os__namespace.arch() || null
+    };
+  } catch {
+    return {
+      platform: null,
+      release: null,
+      architecture: null
+    };
+  }
+}
+function getPlatformVersions() {
+  const versions = {};
+  if (typeof process?.versions === "object") {
+    for (const [key, value] of Object.entries(process.versions)) {
+      versions[key] = value || null;
+    }
+  }
+  return versions;
+}
+function isCi() {
+  return !!(process?.env?.CI || process?.env?.CONTINUOUS_INTEGRATION || process?.env?.GITHUB_ACTIONS || process?.env?.JENKINS_URL || process?.env?.GITLAB_CI || process?.env?.CIRCLECI || process?.env?.TRAVIS || process?.env?.BUILDKITE || process?.env?.DRONE || process?.env?.BITBUCKET_PIPELINES_UUID);
+}
+function getCiPlatform() {
+  if (process?.env?.GITHUB_ACTIONS) return "github-actions";
+  if (process?.env?.JENKINS_URL) return "jenkins";
+  if (process?.env?.GITLAB_CI) return "gitlab-ci";
+  if (process?.env?.CIRCLECI) return "circleci";
+  if (process?.env?.TRAVIS) return "travis";
+  if (process?.env?.BUILDKITE) return "buildkite";
+  if (process?.env?.DRONE) return "drone";
+  if (process?.env?.BITBUCKET_PIPELINES_UUID) return "bitbucket-pipelines";
+  if (process?.env?.CI || process?.env?.CONTINUOUS_INTEGRATION)
+    return "unknown-ci";
+  return null;
+}
+function getMemoryUsage() {
+  if (process?.memoryUsage) {
+    const usage = process.memoryUsage();
+    return usage.rss || null;
+  }
+  return null;
+}
+function getCpuTime() {
+  if (process?.cpuUsage) {
+    const usage = process.cpuUsage();
+    return Math.round((usage.user + usage.system) / 1e3);
+  }
+  return null;
+}
+
+// package.json
+var package_default = {
+  version: "0.13.5"};
+
+// src/plugins/eventEmission/builders.ts
+function createBaseEvent(context = {}) {
+  return {
+    event_id: generateEventId(),
+    timestamp_ms: getCurrentTimestamp(),
+    release_id: getReleaseId(),
+    customuser_id: context.customuser_id,
+    account_id: context.account_id,
+    identity_id: context.identity_id,
+    visitor_id: context.visitor_id,
+    correlation_id: context.correlation_id
+  };
+}
+function buildErrorEvent(data, context = {}) {
+  return {
+    ...createBaseEvent(context),
+    zap_id: context.zap_id,
+    node_id: context.node_id,
+    selected_api: context.selected_api,
+    app_id: context.app_id,
+    app_version_id: context.app_version_id,
+    environment: context.environment,
+    sdk_version: package_default.version,
+    ...data
+  };
+}
+function buildApplicationLifecycleEvent(data, context = {}) {
+  const osInfo = getOsInfo();
+  const platformVersions = getPlatformVersions();
+  return {
+    ...createBaseEvent(context),
+    selected_api: context.selected_api,
+    app_id: context.app_id,
+    app_version_id: context.app_version_id,
+    sdk_version: package_default.version,
+    cli_version: null,
+    memory_usage_bytes: data.memory_usage_bytes ?? getMemoryUsage(),
+    peak_memory_usage_bytes: data.peak_memory_usage_bytes ?? getMemoryUsage(),
+    cpu_time_ms: data.cpu_time_ms ?? getCpuTime(),
+    os_platform: osInfo.platform,
+    os_release: osInfo.release,
+    os_architecture: osInfo.architecture,
+    platform_versions: platformVersions,
+    environment: context.environment ?? (process.env.NODE_ENV || null),
+    is_ci_environment: isCi(),
+    ci_platform: getCiPlatform(),
+    session_id: null,
+    metadata: null,
+    process_argv: process.argv || null,
+    ...data
+  };
+}
+function buildErrorEventWithContext(data, context = {}) {
+  const executionTime = data.execution_start_time ? Date.now() - data.execution_start_time : null;
+  return {
+    ...createBaseEvent(context),
+    zap_id: context.zap_id,
+    node_id: context.node_id,
+    selected_api: context.selected_api,
+    app_id: context.app_id,
+    app_version_id: context.app_version_id,
+    environment: context.environment ?? (process.env.NODE_ENV || null),
+    sdk_version: package_default.version,
+    execution_time_before_error_ms: executionTime,
+    ...data
+  };
+}
+
+// src/plugins/eventEmission/index.ts
+var APPLICATION_LIFECYCLE_EVENT_SUBJECT = "platform.sdk.ApplicationLifecycleEvent";
+var ERROR_OCCURRED_EVENT_SUBJECT = "platform.sdk.ErrorOccurredEvent";
+async function silentEmit(transport, subject, event) {
+  try {
+    transport.emit(subject, event).catch(() => {
+    });
+  } catch {
+  }
+}
+function getTransportConfig() {
+  const envTransport = process?.env?.ZAPIER_SDK_TELEMETRY_TRANSPORT;
+  if (envTransport === "noop" || envTransport === "disabled") {
+    return { type: "noop" };
+  }
+  if (envTransport === "console") {
+    return { type: "console" };
+  }
+  const endpoint = process?.env?.ZAPIER_SDK_TELEMETRY_ENDPOINT || TRACKING_API_ENDPOINT;
+  return {
+    type: "http",
+    endpoint
+  };
+}
+var eventEmissionPlugin = ({ context }) => {
+  const defaultTransport = getTransportConfig();
+  const config = {
+    enabled: context.options.eventEmission?.enabled ?? true,
+    transport: (
+      // If env var is set, use it (defaultTransport will be from env)
+      process?.env?.ZAPIER_SDK_TELEMETRY_TRANSPORT ? defaultTransport : (
+        // Otherwise, use option transport or default
+        context.options.eventEmission?.transport ?? defaultTransport
+      )
+    )
+  };
+  const startupTime = Date.now();
+  let shutdownStartTime = null;
+  if (!config.enabled) {
+    return {
+      context: {
+        eventEmission: {
+          transport: createTransport({ type: "noop" }),
+          config,
+          emit: () => {
+          },
+          createBaseEvent: () => ({
+            event_id: generateEventId(),
+            timestamp_ms: getCurrentTimestamp(),
+            release_id: getReleaseId(),
+            customuser_id: null,
+            account_id: null,
+            identity_id: null,
+            visitor_id: null,
+            correlation_id: null
+          })
+        }
+      }
+    };
+  }
+  let transport;
+  try {
+    transport = createTransport(config.transport || { type: "noop" });
+  } catch {
+    transport = createTransport({ type: "noop" });
+  }
+  const createBaseEventHelper = () => ({
+    event_id: generateEventId(),
+    timestamp_ms: getCurrentTimestamp(),
+    release_id: getReleaseId(),
+    customuser_id: null,
+    account_id: null,
+    identity_id: null,
+    visitor_id: null,
+    correlation_id: null
+  });
+  if (config.enabled) {
+    const startupEvent = buildApplicationLifecycleEvent({
+      lifecycle_event_type: "startup"
+    });
+    silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, startupEvent);
+    if (typeof process?.on === "function") {
+      process.on("exit", (code) => {
+        const uptime = Date.now() - startupTime;
+        const shutdownDuration = shutdownStartTime ? Date.now() - shutdownStartTime : null;
+        const exitEvent = buildApplicationLifecycleEvent({
+          lifecycle_event_type: "exit",
+          exit_code: code,
+          uptime_ms: uptime,
+          is_graceful_shutdown: code === 0,
+          shutdown_duration_ms: shutdownDuration
+        });
+        silentEmit(transport, APPLICATION_LIFECYCLE_EVENT_SUBJECT, exitEvent);
+      });
+      process.on("uncaughtException", async (error) => {
+        const errorEvent = buildErrorEventWithContext({
+          error_message: error.message || "Unknown error",
+          error_type: "UncaughtException",
+          error_stack_trace: error.stack || null,
+          error_severity: "critical",
+          is_user_facing: false,
+          is_recoverable: false,
+          execution_start_time: startupTime
+        });
+        try {
+          await Promise.race([
+            transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
+            new Promise((resolve2) => setTimeout(resolve2, 300))
+          ]);
+        } catch {
+        }
+      });
+      process.on(
+        "unhandledRejection",
+        async (reason, promise) => {
+          const errorMessage = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unhandled promise rejection";
+          const errorStack = reason instanceof Error ? reason.stack : null;
+          const errorEvent = buildErrorEventWithContext({
+            error_message: errorMessage,
+            error_type: "UnhandledRejection",
+            error_stack_trace: errorStack,
+            error_severity: "critical",
+            is_user_facing: false,
+            is_recoverable: false,
+            execution_start_time: startupTime,
+            error_metadata: {
+              promise: String(promise)
+            }
+          });
+          try {
+            await Promise.race([
+              transport.emit(ERROR_OCCURRED_EVENT_SUBJECT, errorEvent),
+              new Promise((resolve2) => setTimeout(resolve2, 300))
+            ]);
+          } catch {
+          }
+        }
+      );
+      const handleSignal = async (signal) => {
+        shutdownStartTime = Date.now();
+        const uptime = Date.now() - startupTime;
+        const signalEvent = buildApplicationLifecycleEvent({
+          lifecycle_event_type: "signal_termination",
+          signal_name: signal,
+          uptime_ms: uptime,
+          is_graceful_shutdown: true
+        });
+        try {
+          await Promise.race([
+            transport.emit(APPLICATION_LIFECYCLE_EVENT_SUBJECT, signalEvent),
+            new Promise((resolve2) => setTimeout(resolve2, 300))
+          ]);
+        } catch {
+        }
+      };
+      ["SIGINT", "SIGTERM"].forEach((signal) => {
+        process.on(signal, () => handleSignal(signal));
+      });
+    }
+  }
+  return {
+    context: {
+      eventEmission: {
+        transport,
+        config,
+        emit: (subject, event) => {
+          silentEmit(transport, subject, event);
+        },
+        createBaseEvent: createBaseEventHelper
+      }
+    }
+  };
+};
+
 // src/sdk.ts
 function createSdk(options = {}, initialSdk = {}, initialContext = { meta: {} }) {
   return {
@@ -3860,7 +4293,7 @@ function createSdk(options = {}, initialSdk = {}, initialContext = { meta: {} })
   };
 }
 function createZapierSdkWithoutRegistry(options = {}) {
-  return createSdk(options).addPlugin(apiPlugin).addPlugin(manifestPlugin).addPlugin(listAppsPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(listInputFieldChoicesPlugin).addPlugin(runActionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
+  return createSdk(options).addPlugin(eventEmissionPlugin).addPlugin(apiPlugin).addPlugin(manifestPlugin).addPlugin(listAppsPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(listInputFieldChoicesPlugin).addPlugin(runActionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
 }
 function createZapierSdk(options = {}) {
   return createZapierSdkWithoutRegistry(options).addPlugin(registryPlugin);
@@ -3898,6 +4331,10 @@ exports.appKeyResolver = appKeyResolver;
 exports.appsPlugin = appsPlugin;
 exports.authenticationIdGenericResolver = authenticationIdGenericResolver;
 exports.authenticationIdResolver = authenticationIdResolver;
+exports.buildApplicationLifecycleEvent = buildApplicationLifecycleEvent;
+exports.buildErrorEvent = buildErrorEvent;
+exports.buildErrorEventWithContext = buildErrorEventWithContext;
+exports.createBaseEvent = createBaseEvent;
 exports.createFunction = createFunction;
 exports.createSdk = createSdk;
 exports.createZapierSdk = createZapierSdk;
@@ -3907,17 +4344,26 @@ exports.findFirstAuthenticationPlugin = findFirstAuthenticationPlugin;
 exports.findManifestEntry = findManifestEntry;
 exports.findUniqueAuthenticationPlugin = findUniqueAuthenticationPlugin;
 exports.formatErrorMessage = formatErrorMessage;
+exports.generateEventId = generateEventId;
 exports.getActionPlugin = getActionPlugin;
 exports.getAppPlugin = getAppPlugin;
 exports.getAuthenticationPlugin = getAuthenticationPlugin;
+exports.getCiPlatform = getCiPlatform;
+exports.getCpuTime = getCpuTime;
+exports.getCurrentTimestamp = getCurrentTimestamp;
+exports.getMemoryUsage = getMemoryUsage;
+exports.getOsInfo = getOsInfo;
+exports.getPlatformVersions = getPlatformVersions;
 exports.getPreferredManifestEntryKey = getPreferredManifestEntryKey;
 exports.getProfilePlugin = getProfilePlugin;
+exports.getReleaseId = getReleaseId;
 exports.getTokenFromCliLogin = getTokenFromCliLogin;
 exports.getTokenFromEnv = getTokenFromEnv;
 exports.getTokenFromEnvOrConfig = getTokenFromEnvOrConfig;
 exports.inputFieldKeyResolver = inputFieldKeyResolver;
 exports.inputsAllOptionalResolver = inputsAllOptionalResolver;
 exports.inputsResolver = inputsResolver;
+exports.isCi = isCi;
 exports.isPositional = isPositional;
 exports.listActionsPlugin = listActionsPlugin;
 exports.listAppsPlugin = listAppsPlugin;