@zapier/zapier-sdk 0.13.2 → 0.13.4

package/src/plugins/eventEmission/transport.test.ts

@@ -0,0 +1,214 @@
+/**
+ * Tests for Event Transport Layer
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  HttpTransport,
+  ConsoleTransport,
+  NoopTransport,
+  createTransport,
+} from "./transport";
+import type { TelemetryEvent } from "../../types/telemetry-events";
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+// Mock console.log
+const mockConsoleLog = vi.spyOn(console, "log").mockImplementation(() => {});
+
+describe("Transport Layer", () => {
+  const sampleEvent: TelemetryEvent = {
+    event_id: "test-123",
+    timestamp_ms: Date.now(),
+    release_id: "test-release",
+    error_message: "Test error",
+    is_user_facing: false,
+  } as any;
+
+  const sampleSubject = "platform.sdk.ErrorOccurredEvent";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("HttpTransport", () => {
+    it("should emit events via HTTP successfully", async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+      });
+
+      const transport = new HttpTransport({
+        endpoint: "https://telemetry.example.com/events",
+        headers: { "x-api-key": "test-key" },
+      });
+
+      await transport.emit(sampleSubject, sampleEvent);
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://telemetry.example.com/events",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": "test-key",
+          },
+          body: JSON.stringify({
+            subject: sampleSubject,
+            properties: sampleEvent,
+          }),
+        },
+      );
+    });
+
+    it("should retry on HTTP failures", async () => {
+      // Fail twice, then succeed
+      mockFetch
+        .mockResolvedValueOnce({ ok: false, status: 500 })
+        .mockResolvedValueOnce({ ok: false, status: 500 })
+        .mockResolvedValueOnce({ ok: true, status: 200 });
+
+      const transport = new HttpTransport({
+        endpoint: "https://telemetry.example.com/events",
+        retryAttempts: 3,
+        retryDelayMs: 10, // Short delay for testing
+      });
+
+      await transport.emit(sampleSubject, sampleEvent);
+
+      expect(mockFetch).toHaveBeenCalledTimes(3);
+    });
+
+    it("should handle network errors silently", async () => {
+      mockFetch.mockRejectedValue(new Error("Network error"));
+
+      const transport = new HttpTransport({
+        endpoint: "https://telemetry.example.com/events",
+        retryAttempts: 1,
+        retryDelayMs: 1,
+      });
+
+      // Should not throw despite network error
+      await expect(
+        transport.emit(sampleSubject, sampleEvent),
+      ).resolves.toBeUndefined();
+    });
+
+    it("should stop retrying after max attempts", async () => {
+      mockFetch.mockResolvedValue({ ok: false, status: 500 });
+
+      const transport = new HttpTransport({
+        endpoint: "https://telemetry.example.com/events",
+        retryAttempts: 2,
+        retryDelayMs: 1,
+      });
+
+      await transport.emit(sampleSubject, sampleEvent);
+
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("ConsoleTransport", () => {
+    it("should log events to console", async () => {
+      const transport = new ConsoleTransport();
+
+      await transport.emit(sampleSubject, sampleEvent);
+
+      expect(mockConsoleLog).toHaveBeenCalledWith(
+        "[SDK Telemetry]",
+        JSON.stringify(
+          { subject: sampleSubject, properties: sampleEvent },
+          null,
+          2,
+        ),
+      );
+    });
+
+    it("should handle console errors silently", async () => {
+      mockConsoleLog.mockImplementation(() => {
+        throw new Error("Console error");
+      });
+
+      const transport = new ConsoleTransport();
+
+      // Should not throw despite console error
+      await expect(
+        transport.emit(sampleSubject, sampleEvent),
+      ).resolves.toBeUndefined();
+    });
+  });
+
+  describe("NoopTransport", () => {
+    it("should do nothing when emitting events", async () => {
+      const transport = new NoopTransport();
+
+      await transport.emit(sampleSubject, sampleEvent);
+
+      // Verify no side effects
+      expect(mockFetch).not.toHaveBeenCalled();
+      expect(mockConsoleLog).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("createTransport", () => {
+    it("should create HTTP transport with valid config", () => {
+      const transport = createTransport({
+        type: "http",
+        endpoint: "https://example.com",
+        headers: { "x-key": "value" },
+        retryAttempts: 5,
+        retryDelayMs: 2000,
+      });
+
+      expect(transport).toBeInstanceOf(HttpTransport);
+    });
+
+    it("should create console transport", () => {
+      const transport = createTransport({
+        type: "console",
+      });
+
+      expect(transport).toBeInstanceOf(ConsoleTransport);
+    });
+
+    it("should create noop transport by default", () => {
+      const transport = createTransport({
+        type: "noop",
+      });
+
+      expect(transport).toBeInstanceOf(NoopTransport);
+    });
+
+    it("should fallback to noop transport on invalid HTTP config", () => {
+      const transport = createTransport({
+        type: "http",
+        // Missing endpoint
+      });
+
+      expect(transport).toBeInstanceOf(NoopTransport);
+    });
+
+    it("should fallback to noop transport on unknown type", () => {
+      const transport = createTransport({
+        type: "unknown" as any,
+      });
+
+      expect(transport).toBeInstanceOf(NoopTransport);
+    });
+
+    it("should handle transport creation errors gracefully", () => {
+      // Since createTransport already handles errors internally,
+      // this test verifies that invalid configs don't throw
+      expect(() => {
+        const transport = createTransport({
+          type: "http" as const,
+          // Missing required endpoint - should fallback to noop
+        });
+        expect(transport).toBeInstanceOf(NoopTransport);
+      }).not.toThrow();
+    });
+  });
+});

package/src/plugins/eventEmission/transport.ts

@@ -0,0 +1,135 @@
+/**
+ * Transport abstraction layer for event emission
+ *
+ * Provides configurable transport mechanisms for emitting telemetry events.
+ * All transports implement silent failure to prevent SDK disruption.
+ */
+
+// Constants for transport configuration
+const DEFAULT_RETRY_ATTEMPTS = 2;
+const DEFAULT_RETRY_DELAY_MS = 300;
+
+// Transport interface - all implementations must be async and silent
+export interface EventTransport {
+  emit<T extends any>(subject: string, event: T): Promise<void>;
+  close?(): Promise<void>;
+}
+
+// Transport configuration
+export interface TransportConfig {
+  type: "http" | "console" | "noop";
+  endpoint?: string;
+  headers?: Record<string, string>;
+  retryAttempts?: number;
+  retryDelayMs?: number;
+}
+
+// HTTP Transport - sends events to remote endpoint
+export class HttpTransport implements EventTransport {
+  constructor(
+    private config: {
+      endpoint: string;
+      headers?: Record<string, string>;
+      retryAttempts?: number;
+      retryDelayMs?: number;
+    },
+  ) {}
+
+  async emit<T extends any>(subject: string, event: T): Promise<void> {
+    try {
+      await this.emitWithRetry(
+        subject,
+        event,
+        this.config.retryAttempts || DEFAULT_RETRY_ATTEMPTS,
+      );
+    } catch {
+      // Silent failure - never throw
+    }
+  }
+
+  private async emitWithRetry<T extends any>(
+    subject: string,
+    event: T,
+    attemptsLeft: number,
+  ): Promise<void> {
+    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;
+    }
+  }
+
+  private async delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+// Console Transport - logs events to console (for development)
+export class ConsoleTransport implements EventTransport {
+  async emit<T extends any>(subject: string, event: T): Promise<void> {
+    try {
+      console.log(
+        "[SDK Telemetry]",
+        JSON.stringify({ subject, properties: event }, null, 2),
+      );
+    } catch {
+      // Silent failure - never throw
+    }
+  }
+}
+
+// No-op Transport - discards all events (for testing/disabled state)
+export class NoopTransport implements EventTransport {
+  async emit<T extends any>(_subject: string, _event: T): Promise<void> {
+    // Intentionally do nothing
+  }
+}
+
+// Transport factory
+export function createTransport(config: TransportConfig): EventTransport {
+  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 {
+    // If transport creation fails, return noop to maintain silent operation
+    return new NoopTransport();
+  }
+}

package/src/plugins/eventEmission/types.ts

@@ -0,0 +1,58 @@
+// Common context that can be injected into events
+export interface EventContext {
+  customuser_id?: number | null;
+  account_id?: number | null;
+  identity_id?: number | null;
+  visitor_id?: string | null;
+  correlation_id?: string | null;
+  selected_api?: string | null;
+  app_id?: number | null;
+  app_version_id?: number | null;
+  zap_id?: number | null;
+  node_id?: number | null;
+  environment?: string | null;
+  sdk_version?: string | null;
+  operation_type?: string | null;
+}
+
+export interface ErrorEventData {
+  error_message: string;
+  is_user_facing: boolean;
+  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_recoverable?: boolean | 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;
+  execution_time_before_error_ms?: number | null;
+}
+
+// Enhanced Error Event Builder with runtime context
+export interface EnhancedErrorEventData extends ErrorEventData {
+  execution_start_time?: number | null;
+}
+
+export interface ApplicationLifecycleEventData {
+  lifecycle_event_type: "startup" | "exit" | "signal_termination";
+  exit_code?: number | null;
+  signal_name?: string | null;
+  uptime_ms?: number | null;
+  is_graceful_shutdown?: boolean | null;
+  shutdown_duration_ms?: number | null;
+  // Allow overriding auto-gathered system info if needed
+  memory_usage_bytes?: number | null;
+  peak_memory_usage_bytes?: number | null;
+  cpu_time_ms?: number | null;
+  active_requests_count?: number | null;
+}

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/getAction/index.ts

@@ -36,9 +36,12 @@ export const getActionPlugin: Plugin<
     // Use the listActions function from the SDK to search for the specific action
     const actionsResult = await sdk.listActions({ appKey });
 
-    // Search through all actions to find the matching one
+    // Search through all actions to find the matching one (by key or ID)
     for (const action of actionsResult.data) {
-      if (action.key === actionKey && action.action_type === actionType) {
+      if (
+        (action.key === actionKey || action.id === actionKey) &&
+        action.action_type === actionType
+      ) {
         return { data: action };
       }
     }

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

@@ -5,6 +5,10 @@ import {
   ZapierApiError,
 } from "../../types/errors";
 import { listInputFieldsPlugin } from "./index";
+import { getActionPlugin } from "../getAction";
+import { getAppPlugin } from "../getApp";
+import { listActionsPlugin } from "../listActions";
+import { listAppsPlugin } from "../listApps";
 import { createSdk } from "../../sdk";
 import type { ApiClient } from "../../api";
 import type { ListInputFieldsOptions } from "./schemas";
@@ -45,6 +49,28 @@ const mockNeedsResponse: NeedsResponse = {
   needs: mockNeeds,
 };
 
+const mockActionsResponse = {
+  results: [
+    {
+      slug: "slack",
+      selected_api: "slack",
+      actions: [
+        {
+          key: "send_message",
+          name: "Send Message",
+          description: "Send a message to a channel",
+          type_of: "write",
+          type: "write",
+          id: "core:12345",
+        },
+      ],
+    },
+  ],
+  meta: {
+    next_cursor: null,
+  },
+};
+
 describe("listInputFields plugin", () => {
   let mockApiClient: ApiClient;
   let mockGetVersionedImplementationId: any;
@@ -52,6 +78,7 @@ describe("listInputFields plugin", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockApiClient = {
+      get: vi.fn().mockResolvedValue(mockActionsResponse),
       post: vi.fn().mockResolvedValue(mockNeedsResponse),
     } as Partial<ApiClient> as ApiClient;
 
@@ -69,7 +96,12 @@ describe("listInputFields plugin", () => {
         meta: {},
         getVersionedImplementationId: mockGetVersionedImplementationId,
       },
-    ).addPlugin(listInputFieldsPlugin as any);
+    )
+      .addPlugin(listAppsPlugin as any)
+      .addPlugin(listActionsPlugin as any)
+      .addPlugin(getAppPlugin as any)
+      .addPlugin(getActionPlugin as any)
+      .addPlugin(listInputFieldsPlugin as any);
   }
 
   describe("schema validation", () => {
@@ -319,7 +351,7 @@ describe("listInputFields plugin", () => {
     it("should throw ZapierApiError when API response indicates failure", async () => {
       mockApiClient.post = vi.fn().mockResolvedValue({
         success: false,
-        errors: ["Invalid action", "Missing parameter"],
+        errors: ["Authentication failed", "Invalid credentials"],
       });
 
       const sdk = createTestSdk();
@@ -327,7 +359,7 @@ describe("listInputFields plugin", () => {
         sdk.listInputFields({
           appKey: "slack",
           actionType: "write",
-          actionKey: "invalid_action",
+          actionKey: "send_message", // Use valid action so we get to the POST call
         }),
       ).rejects.toThrow(ZapierApiError);
 
@@ -335,10 +367,10 @@ describe("listInputFields plugin", () => {
         sdk.listInputFields({
           appKey: "slack",
           actionType: "write",
-          actionKey: "invalid_action",
+          actionKey: "send_message", // Use valid action so we get to the POST call
         }),
       ).rejects.toThrow(
-        "Failed to get action fields: Invalid action, Missing parameter",
+        "Failed to get action fields: Authentication failed, Invalid credentials",
       );
     });
 

package/src/plugins/listInputFields/index.ts

@@ -15,6 +15,7 @@ import {
 import { ZapierConfigurationError, ZapierApiError } from "../../types/errors";
 import { createPaginatedFunction } from "../../utils/function-utils";
 import type { GetAppPluginProvides } from "../getApp";
+import type { GetActionPluginProvides } from "../getAction";
 import type { GetVersionedImplementationId } from "../manifest/schemas";
 import {
   appKeyResolver,
@@ -196,13 +197,13 @@ export interface ListInputFieldsPluginProvides {
 }
 
 export const listInputFieldsPlugin: Plugin<
-  GetSdkType<GetAppPluginProvides>, // requires getApp in SDK
+  GetSdkType<GetAppPluginProvides & GetActionPluginProvides>, // requires getApp and getAction in SDK
   {
     api: ApiClient;
     getVersionedImplementationId: GetVersionedImplementationId;
   }, // requires api and getVersionedImplementationId in context
   ListInputFieldsPluginProvides
-> = ({ context }) => {
+> = ({ sdk, context }) => {
   const listInputFields = createPaginatedFunction(
     async function listInputFieldsPage(
       options: ListInputFieldsOptions & { cursor?: string } & {
@@ -226,10 +227,16 @@ export const listInputFieldsPlugin: Plugin<
         );
       }
 
+      const { data: action } = await sdk.getAction({
+        appKey,
+        actionType,
+        actionKey,
+      });
+
       // Build needs request
       const needsRequest: NeedsRequest = {
         selected_api: selectedApi,
-        action: actionKey,
+        action: action.key,
         type_of: actionType,
         params: inputs || {},
       };