@zapier/zapier-sdk 0.13.3 → 0.13.5

package/src/plugins/eventEmission/utils.ts

@@ -0,0 +1,121 @@
+/**
+ * Simple utility functions for event emission
+ * These are pure functions that can be used to populate common event fields
+ */
+
+import * as os from "os";
+
+/**
+ * Generate a unique event ID
+ */
+export function generateEventId(): string {
+  return crypto.randomUUID();
+}
+
+/**
+ * Get current timestamp in milliseconds since epoch
+ */
+export function getCurrentTimestamp(): number {
+  return Date.now();
+}
+
+/**
+ * Get release ID (git SHA) - in production this would come from build process
+ */
+export function getReleaseId(): string {
+  return process?.env?.SDK_RELEASE_ID || "development";
+}
+
+/**
+ * Get operating system information
+ */
+export function getOsInfo(): {
+  platform: string | null;
+  release: string | null;
+  architecture: string | null;
+} {
+  try {
+    return {
+      platform: os.platform() || null,
+      release: os.release() || null,
+      architecture: os.arch() || null,
+    };
+  } catch {
+    // Browser environment - os module not available
+    return {
+      platform: null,
+      release: null,
+      architecture: null,
+    };
+  }
+}
+
+/**
+ * Get platform versions (Node.js, npm, etc.)
+ */
+export function getPlatformVersions(): Record<string, string | null> {
+  const versions: Record<string, string | null> = {};
+  if (typeof process?.versions === "object") {
+    for (const [key, value] of Object.entries(process.versions)) {
+      versions[key] = value || null;
+    }
+  }
+  return versions;
+}
+
+/**
+ * Check if running in CI environment
+ */
+export function isCi(): boolean {
+  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
+  );
+}
+
+/**
+ * Get CI platform name if running in CI
+ */
+export function getCiPlatform(): string | null {
+  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;
+}
+
+/**
+ * Get memory usage in bytes
+ */
+export function getMemoryUsage(): number | null {
+  if (process?.memoryUsage) {
+    const usage = process.memoryUsage();
+    return usage.rss || null; // Resident Set Size
+  }
+  return null;
+}
+
+/**
+ * Get CPU time in milliseconds
+ */
+export function getCpuTime(): number | null {
+  if (process?.cpuUsage) {
+    const usage = process.cpuUsage();
+    return Math.round((usage.user + usage.system) / 1000); // Convert to milliseconds
+  }
+  return null;
+}

package/src/plugins/listActions/index.test.ts

@@ -85,7 +85,9 @@ describe("listActions plugin", () => {
           manifest: null,
           getVersionedImplementationId: mockGetVersionedImplementationId,
           resolveAppKeys: mockResolveAppKeys,
-          updateManifestEntry: vi.fn().mockResolvedValue(["test-key", {}]),
+          updateManifestEntry: vi
+            .fn()
+            .mockResolvedValue(["test-key", {}, { apps: {} }]),
         },
       }))
       .addPlugin(listAppsPlugin)

package/src/plugins/listAuthentications/index.test.ts

@@ -69,7 +69,9 @@ describe("listAuthentications plugin", () => {
       manifest: null,
       getVersionedImplementationId: mockGetVersionedImplementationId,
       resolveAppKeys: mockResolveAppKeys,
-      updateManifestEntry: vi.fn().mockResolvedValue(["test-key", {}]),
+      updateManifestEntry: vi
+        .fn()
+        .mockResolvedValue(["test-key", {}, { apps: {} }]),
     },
   });
 

package/src/plugins/manifest/index.test.ts

@@ -491,10 +491,10 @@ describe("manifestPlugin", () => {
       const context = sdk.getContext();
 
       // This should now find the existing "SlackCLIAPI" entry
-      const [manifestKey] = await context.updateManifestEntry(
-        "slack", // Input is slug
-        { implementationName: "SlackCLIAPI", version: "1.30.0" },
-      );
+      const [manifestKey] = await context.updateManifestEntry({
+        appKey: "slack", // Input is slug
+        entry: { implementationName: "SlackCLIAPI", version: "1.30.0" },
+      });
 
       // Should return the existing key, not create a new one
       expect(manifestKey).toBe("SlackCLIAPI");

package/src/plugins/manifest/index.ts

@@ -27,15 +27,21 @@ import { toArrayFromAsync } from "../../utils/array-utils";
 
 export type ManifestPluginOptions = z.infer<typeof ManifestPluginOptionsSchema>;
 
+export interface UpdateManifestEntryOptions {
+  appKey: string;
+  entry: ManifestEntry;
+  configPath?: string;
+  skipWrite?: boolean;
+  manifest?: Manifest;
+}
+
 export interface ManifestPluginProvides {
   context: {
     getVersionedImplementationId: GetVersionedImplementationId;
     resolveAppKeys: ResolveAppKeys;
     updateManifestEntry: (
-      appKey: string,
-      entry: ManifestEntry,
-      configPath?: string,
-    ) => Promise<[string, ManifestEntry]>;
+      options: UpdateManifestEntryOptions,
+    ) => Promise<[string, ManifestEntry, Manifest]>;
   };
 }
 
@@ -319,6 +325,7 @@ async function resolveAppKeys({
 }
 
 export { DEFAULT_CONFIG_PATH } from "./schemas";
+export type { ManifestEntry, Manifest } from "./schemas";
 
 export const manifestPlugin: Plugin<
   {}, // no SDK dependencies
@@ -365,11 +372,19 @@ export const manifestPlugin: Plugin<
   };
 
   const updateManifestEntry = async (
-    appKey: string,
-    entry: ManifestEntry,
-    configPath: string = DEFAULT_CONFIG_PATH,
-  ): Promise<[string, ManifestEntry]> => {
-    const manifest = (await readManifestFromFile(configPath)) || { apps: {} };
+    options: UpdateManifestEntryOptions,
+  ): Promise<[string, ManifestEntry, Manifest]> => {
+    const {
+      appKey,
+      entry,
+      configPath = DEFAULT_CONFIG_PATH,
+      skipWrite = false,
+      manifest: inputManifest,
+    } = options;
+
+    // Use provided manifest or read from file
+    const manifest = inputManifest ||
+      (await readManifestFromFile(configPath)) || { apps: {} };
 
     // Try to find existing entry by direct key first
     let existingEntry = findManifestEntry({
@@ -412,13 +427,23 @@ export const manifestPlugin: Plugin<
       });
     }
 
-    manifest.apps[manifestKey] = entry;
-    await writeManifestToFile(manifest, configPath);
+    const updatedManifest = {
+      ...manifest,
+      apps: {
+        ...manifest.apps,
+        [manifestKey]: entry,
+      },
+    };
+
+    // Conditionally write to file
+    if (!skipWrite) {
+      await writeManifestToFile(updatedManifest, configPath);
 
-    // Clear the cached manifest so it gets reloaded with the new data
-    resolvedManifest = undefined;
+      // Clear the cached manifest so it gets reloaded with the new data
+      resolvedManifest = undefined;
+    }
 
-    return [manifestKey, entry];
+    return [manifestKey, entry, updatedManifest];
   };
 
   return {

package/src/resolvers/actionType.ts

@@ -16,9 +16,10 @@ export const actionTypeResolver: DynamicResolver<
       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: string[] = [...new Set(actionTypes)];
     return types.map((type) => ({ key: type, name: type }));
   },
   prompt: (types) => ({

package/src/resolvers/authenticationId.ts

@@ -23,7 +23,8 @@ export const authenticationIdResolver: AuthenticationIdResolver = {
 
     // Filter out myAuths from allAuths
     const otherAuths = allAuths.data.filter(
-      (auth) => !myAuths.data.some((myAuth) => myAuth.id === auth.id),
+      (auth: { id: number }) =>
+        !myAuths.data.some((myAuth: { id: number }) => myAuth.id === auth.id),
     );
     return [...myAuths.data, ...otherAuths];
   },

package/src/sdk.ts

@@ -33,6 +33,7 @@ import { listInputFieldsPlugin } from "./plugins/listInputFields";
 import { listInputFieldChoicesPlugin } from "./plugins/listInputFieldChoices";
 import { requestPlugin } from "./plugins/request";
 import { manifestPlugin } from "./plugins/manifest";
+import { eventEmissionPlugin } from "./plugins/eventEmission";
 
 // Full SDK interface with plugins applied
 // Note: ZapierSdk is now defined as ReturnType<typeof createZapierSdk> at the bottom of this file
@@ -130,10 +131,13 @@ export function createSdk<
 export function createZapierSdkWithoutRegistry(options: ZapierSdkOptions = {}) {
   return (
     createSdk(options)
+      // Event emission (must be first to be available to other plugins)
+      .addPlugin(eventEmissionPlugin)
+
       // Provides the API client in context
       .addPlugin(apiPlugin)
 
-      // Manifest plugin (provides version locking context)
+      // Manifest plugin (provides version locking context) - must come after apiPlugin
       .addPlugin(manifestPlugin)
 
       // Apps/actions/fields

package/src/types/sdk.ts

@@ -3,6 +3,7 @@
  */
 
 import type { EventCallback } from "./events";
+import type { EventEmissionConfig } from "../plugins/eventEmission";
 
 // SDK Configuration Types
 export interface BaseSdkOptions {
@@ -21,6 +22,7 @@ export interface BaseSdkOptions {
       };
     };
   };
+  eventEmission?: EventEmissionConfig;
 }
 
 // SDK interface composed from individual function interfaces
@@ -33,6 +35,8 @@ import type { RelayRequestSdkFunction } from "../plugins/request/schemas";
 import type { z } from "zod";
 import type { RegistryPluginProvides } from "../plugins/registry";
 import type { GetProfilePluginProvides } from "../plugins/getProfile";
+import type { EventEmissionProvides } from "../plugins/eventEmission";
+import type { ApiPluginProvides } from "../plugins/api";
 import type { AppsPluginProvides, ZapierSdkApps } from "../plugins/apps";
 import type { ActionProxy } from "../plugins/apps/schemas";
 import type { FetchPluginProvides } from "../plugins/fetch";
@@ -104,7 +108,9 @@ export interface ZapierSdk
       ListInputFieldsPluginProvides &
       ListInputFieldChoicesPluginProvides &
       RequestPluginProvides &
-      GetProfilePluginProvides
+      GetProfilePluginProvides &
+      EventEmissionProvides &
+      ApiPluginProvides
   > {
   // Override apps property to intersect ActionProxy with our typed apps
   apps: ActionProxy & ZapierSdkApps;

package/src/types/telemetry-events.ts

@@ -0,0 +1,85 @@
+/**
+ * Event emission types matching Avro schemas for SDK telemetry
+ *
+ * These interfaces correspond to the Avro schemas:
+ * - application_lifecycle_event.avsc
+ * - error_occurred_event.avsc
+ */
+
+// Common fields present in all events
+export interface BaseEvent {
+  event_id: string;
+  timestamp_ms: number;
+  release_id: string;
+  customuser_id?: number | null;
+  account_id?: number | null;
+  identity_id?: number | null;
+  visitor_id?: string | null;
+  correlation_id?: string | null;
+}
+
+// Error Event - tracks SDK errors and exceptions
+export interface ErrorOccurredEvent extends BaseEvent {
+  zap_id?: number | null;
+  node_id?: number | null;
+  selected_api?: string | null;
+  app_id?: number | null;
+  app_version_id?: number | null;
+  error_message: string;
+  error_type?: string | null;
+  error_status_code?: number | null;
+  error_stack_trace?: string | null;
+  error_source_method?: string | null;
+  error_source_file?: string | null;
+  error_line_number?: number | null;
+  operation_type?: string | null;
+  operation_key?: string | null;
+  error_severity?: string | null;
+  is_user_facing: boolean;
+  is_recoverable?: boolean | null;
+  sdk_version?: string | null;
+  error_metadata?: Record<string, string | null> | null;
+  parent_error_id?: string | null;
+  error_occurred_timestamp_ms?: number | null;
+  error_code?: string | null;
+  recovery_attempted?: boolean | null;
+  recovery_action?: string | null;
+  recovery_successful?: boolean | null;
+  environment?: string | null;
+  execution_time_before_error_ms?: number | null;
+}
+
+// Application Lifecycle Event - tracks SDK application lifecycle transitions
+export interface ApplicationLifecycleEvent extends BaseEvent {
+  lifecycle_event_type: "startup" | "exit" | "signal_termination";
+  selected_api?: string | null;
+  app_id?: number | null;
+  app_version_id?: number | null;
+  sdk_version?: string | null;
+  cli_version?: string | null;
+  exit_code?: number | null;
+  signal_name?: string | null;
+  uptime_ms?: number | null;
+  memory_usage_bytes?: number | null;
+  peak_memory_usage_bytes?: number | null;
+  cpu_time_ms?: number | null;
+  os_platform?: string | null;
+  os_release?: string | null;
+  os_architecture?: string | null;
+  platform_versions?: Record<string, string | null> | null;
+  environment?: string | null;
+  is_ci_environment?: boolean | null;
+  ci_platform?: string | null;
+  session_id?: string | null;
+  metadata?: Record<string, string | null> | null;
+  process_argv?: (string | null)[] | null;
+  is_graceful_shutdown?: boolean | null;
+  shutdown_duration_ms?: number | null;
+  active_requests_count?: number | null;
+}
+
+// Union type for all telemetry events
+export type TelemetryEvent = ErrorOccurredEvent | ApplicationLifecycleEvent;
+
+// Event type discriminator
+export type TelemetryEventType = "error_occurred" | "application_lifecycle";