@zapier/zapier-sdk 0.13.5 → 0.13.7

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

@@ -1,214 +0,0 @@
-/**
- * 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

@@ -1,135 +0,0 @@
-/**
- * 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

@@ -1,58 +0,0 @@
-// 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

@@ -1,121 +0,0 @@
-/**
- * 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/fetch/index.ts

@@ -1,83 +0,0 @@
-import type { RelayRequestOptions } from "../request/schemas";
-import type { Plugin, GetSdkType } from "../../types/plugin";
-import type { RequestPluginProvides } from "../request";
-import { FetchUrlSchema, FetchInitSchema } from "./schemas";
-import type { z } from "zod";
-
-export interface FetchPluginProvides {
-  fetch: (
-    url: string | URL,
-    init?: RequestInit & {
-      authenticationId?: number;
-      callbackUrl?: string;
-      authenticationTemplate?: string;
-    },
-  ) => Promise<Response>;
-  context: {
-    meta: {
-      fetch: {
-        packages: string[];
-        categories: string[];
-        returnType: string;
-        inputParameters: Array<{ name: string; schema: z.ZodSchema }>;
-      };
-    };
-  };
-}
-
-/**
- * Direct plugin function - takes options + sdk + context in one object
- */
-export const fetchPlugin: Plugin<
-  GetSdkType<RequestPluginProvides>, // requires request in SDK
-  {}, // requires no context (uses SDK methods)
-  FetchPluginProvides
-> = ({ sdk }) => {
-  // Return flat structure - fetch goes directly to SDK
-  return {
-    fetch: async function fetch(
-      url: string | URL,
-      init?: RequestInit & {
-        authenticationId?: number;
-        callbackUrl?: string;
-        authenticationTemplate?: string;
-      },
-    ): Promise<Response> {
-      const {
-        authenticationId,
-        callbackUrl,
-        authenticationTemplate,
-        ...fetchInit
-      } = init || {};
-
-      return sdk.request({
-        url: url.toString(),
-        method: fetchInit.method as RelayRequestOptions["method"],
-        body: fetchInit.body,
-        headers: fetchInit.headers,
-        authenticationId,
-        callbackUrl,
-        authenticationTemplate,
-      });
-    },
-    context: {
-      meta: {
-        fetch: {
-          packages: ["sdk"],
-          categories: ["http"],
-          returnType: "Response",
-          inputParameters: [
-            { name: "url", schema: FetchUrlSchema },
-            { name: "init", schema: FetchInitSchema },
-          ],
-        },
-      },
-    },
-  };
-};
-
-export type ZapierFetchInitOptions = RequestInit & {
-  authenticationId?: number;
-  callbackUrl?: string;
-  authenticationTemplate?: string;
-};

package/src/plugins/fetch/schemas.ts

@@ -1,37 +0,0 @@
-import { z } from "zod";
-
-// Schemas for fetch function parameters
-export const FetchUrlSchema = z
-  .union([z.string(), z.instanceof(URL)])
-  .describe("The URL to fetch");
-
-export const FetchInitSchema = z
-  .object({
-    method: z
-      .enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
-      .optional(),
-    headers: z.record(z.string()).optional(),
-    body: z
-      .union([
-        z.string(),
-        z.instanceof(FormData),
-        z.instanceof(URLSearchParams),
-      ])
-      .optional(),
-    authenticationId: z
-      .number()
-      .optional()
-      .describe("Zapier authentication ID to use for the request"),
-    callbackUrl: z
-      .string()
-      .optional()
-      .describe("URL to send async response to (makes request async)"),
-    authenticationTemplate: z
-      .string()
-      .optional()
-      .describe(
-        "Optional JSON string authentication template to bypass Notary lookup",
-      ),
-  })
-  .optional()
-  .describe("Fetch options including authentication");