@zapier/zapier-sdk 0.0.3 → 0.1.1

package/dist/types/properties.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const AppKeyPropertySchema: z.ZodString;
+export declare const ActionTypePropertySchema: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+export declare const ActionKeyPropertySchema: z.ZodString;
+export declare const AuthenticationIdPropertySchema: z.ZodNumber;
+export declare const InputsPropertySchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+export declare const LimitPropertySchema: z.ZodDefault<z.ZodNumber>;
+export declare const OffsetPropertySchema: z.ZodDefault<z.ZodNumber>;
+export declare const OutputPropertySchema: z.ZodString;
+export declare const DebugPropertySchema: z.ZodDefault<z.ZodBoolean>;
+export declare const ParamsPropertySchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+export type AppKeyProperty = z.infer<typeof AppKeyPropertySchema>;
+export type ActionTypeProperty = z.infer<typeof ActionTypePropertySchema>;
+export type ActionKeyProperty = z.infer<typeof ActionKeyPropertySchema>;
+export type AuthenticationIdProperty = z.infer<typeof AuthenticationIdPropertySchema>;
+export type InputsProperty = z.infer<typeof InputsPropertySchema>;
+export type LimitProperty = z.infer<typeof LimitPropertySchema>;
+export type OffsetProperty = z.infer<typeof OffsetPropertySchema>;
+export type OutputProperty = z.infer<typeof OutputPropertySchema>;
+export type DebugProperty = z.infer<typeof DebugPropertySchema>;
+export type ParamsProperty = z.infer<typeof ParamsPropertySchema>;

package/dist/types/properties.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamsPropertySchema = exports.DebugPropertySchema = exports.OutputPropertySchema = exports.OffsetPropertySchema = exports.LimitPropertySchema = exports.InputsPropertySchema = exports.AuthenticationIdPropertySchema = exports.ActionKeyPropertySchema = exports.ActionTypePropertySchema = exports.AppKeyPropertySchema = void 0;
+const zod_1 = require("zod");
+const schema_utils_1 = require("../schema-utils");
+// Shared property definitions for common parameters across functions
+// These can be reused in function schemas without duplication
+exports.AppKeyPropertySchema = (0, schema_utils_1.withPositional)(zod_1.z.string().min(1).describe("App slug (e.g., 'slack', 'github')"));
+exports.ActionTypePropertySchema = zod_1.z
+    .enum(["read", "write", "search", "create", "update", "delete"])
+    .describe("Action type that matches the action's defined type");
+exports.ActionKeyPropertySchema = zod_1.z
+    .string()
+    .min(1)
+    .describe("Action key to execute");
+exports.AuthenticationIdPropertySchema = zod_1.z
+    .number()
+    .int()
+    .describe("Authentication ID to use for this action");
+exports.InputsPropertySchema = zod_1.z
+    .record(zod_1.z.any())
+    .describe("Input parameters for the action");
+exports.LimitPropertySchema = zod_1.z
+    .number()
+    .int()
+    .min(1)
+    .max(1000)
+    .default(50)
+    .describe("Maximum number of items to return");
+exports.OffsetPropertySchema = zod_1.z
+    .number()
+    .int()
+    .min(0)
+    .default(0)
+    .describe("Number of items to skip for pagination");
+exports.OutputPropertySchema = zod_1.z.string().describe("Output file path");
+exports.DebugPropertySchema = zod_1.z
+    .boolean()
+    .default(false)
+    .describe("Enable debug logging");
+exports.ParamsPropertySchema = zod_1.z
+    .record(zod_1.z.any())
+    .describe("Additional parameters");

package/dist/types/sdk.d.ts

@@ -0,0 +1,23 @@
+import type { ListActionsSdkFunction } from "../functions/listActions/schemas";
+import type { GetActionSdkFunction } from "../functions/getAction/schemas";
+import type { GetAppSdkFunction } from "../functions/getApp/schemas";
+import type { RunActionSdkFunction } from "../functions/runAction/schemas";
+import type { ListFieldsSdkFunction } from "../functions/listFields/schemas";
+import type { ListAuthenticationsSdkFunction } from "../functions/listAuthentications/schemas";
+import type { FindFirstAuthenticationSdkFunction } from "../functions/findFirstAuthentication/schemas";
+import type { FindUniqueAuthenticationSdkFunction } from "../functions/findUniqueAuthentication/schemas";
+import type { GenerateTypesSdkFunction } from "../functions/generateTypes/schemas";
+import type { ListAppsSdkFunction } from "../functions/listApps/schemas";
+import type { BundleCodeSdkFunction } from "../functions/bundleCode/schemas";
+import type { AppsPluginSdkExtension } from "../plugins/apps/types";
+export interface ZapierSdkFunctions extends ListActionsSdkFunction, GetActionSdkFunction, GetAppSdkFunction, RunActionSdkFunction, ListFieldsSdkFunction, ListAuthenticationsSdkFunction, FindFirstAuthenticationSdkFunction, FindUniqueAuthenticationSdkFunction, GenerateTypesSdkFunction, ListAppsSdkFunction, BundleCodeSdkFunction {
+}
+export interface ZapierSdkPlugins extends AppsPluginSdkExtension {
+}
+export interface ZapierSdk extends ZapierSdkFunctions, ZapierSdkPlugins {
+    __registry: Array<{
+        name: string;
+        inputSchema: any;
+        implementation: Function;
+    }>;
+}

package/dist/types/sdk.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk",
-  "version": "0.0.3",
+  "version": "0.1.1",
   "description": "Complete Zapier SDK - combines all Zapier SDK packages",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,9 @@
     "typescript": "^5.8.3"
   },
   "scripts": {
-    "build": "tsc --project tsconfig.build.json",
+    "build": "rm -rf dist && tsc --project tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "rebuild": "pnpm clean && pnpm build",
     "dev": "tsc --watch",
     "typecheck": "tsc --project tsconfig.build.json --noEmit"
   }

package/src/api/auth.ts

@@ -0,0 +1,28 @@
+/**
+ * Authentication Utilities
+ *
+ * This module provides utilities for handling authentication tokens,
+ * including JWT detection and authorization header generation.
+ */
+
+export function isJwt(token: string): boolean {
+  // JWT tokens have exactly 3 parts separated by dots
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    return false;
+  }
+
+  // Each part should be base64url encoded (no padding)
+  // Basic validation - each part should be non-empty and contain valid base64url characters
+  const base64UrlPattern = /^[A-Za-z0-9_-]+$/;
+  return parts.every((part) => part.length > 0 && base64UrlPattern.test(part));
+}
+
+export function getAuthorizationHeader(token: string): string {
+  // Check if token is a JWT (has 3 parts separated by dots)
+  if (isJwt(token)) {
+    return `JWT ${token}`;
+  }
+  // Default to Bearer for other token types
+  return `Bearer ${token}`;
+}

package/src/api/client.ts

@@ -0,0 +1,148 @@
+/**
+ * API Client Implementation
+ *
+ * This module contains the core API client implementation, including
+ * HTTP method handlers, response processing, and client factory functions.
+ */
+
+import type {
+  ApiClient,
+  ApiClientOptions,
+  RequestOptions,
+  PollOptions,
+} from "./types";
+import { getAuthorizationHeader } from "./auth";
+import { createDebugLogger, createDebugFetch } from "./debug";
+import { pollUntilComplete } from "./polling";
+
+export function createZapierApi(options: ApiClientOptions): ApiClient {
+  const {
+    baseUrl,
+    token,
+    debug = false,
+    fetch: originalFetch = globalThis.fetch,
+  } = options;
+
+  const debugLog = createDebugLogger(debug);
+  const fetch = createDebugFetch({ originalFetch, debugLog });
+
+  // Helper to build full URLs
+  function buildUrl(
+    path: string,
+    searchParams?: Record<string, string>,
+  ): string {
+    const url = new URL(path, baseUrl);
+    if (searchParams) {
+      Object.entries(searchParams).forEach(([key, value]) => {
+        url.searchParams.set(key, value);
+      });
+    }
+    return url.toString();
+  }
+
+  // Helper to build headers
+  function buildHeaders(options: RequestOptions = {}): Record<string, string> {
+    const headers: Record<string, string> = {
+      ...options.headers,
+    };
+
+    // Add auth header if token provided and not explicitly disabled
+    if (token && options.authRequired !== false) {
+      headers.Authorization = getAuthorizationHeader(token);
+    }
+
+    return headers;
+  }
+
+  // Helper to handle responses
+  async function handleResponse(
+    response: Response,
+    customErrorHandler?: (response: Response) => Error | undefined,
+  ): Promise<any> {
+    if (!response.ok) {
+      // Check for custom error handling first
+      if (customErrorHandler) {
+        const customError = customErrorHandler(response);
+        if (customError) {
+          throw customError;
+        }
+      }
+
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    // Try to parse JSON, fall back to text if that fails
+    try {
+      return await response.json();
+    } catch {
+      return await response.text();
+    }
+  }
+
+  // Helper to perform HTTP requests with JSON handling
+  async function fetchJson(
+    method: string,
+    path: string,
+    data?: any,
+    options: RequestOptions = {},
+  ): Promise<any> {
+    const url = buildUrl(path, options.searchParams);
+    const headers = buildHeaders(options);
+
+    // Add Content-Type for JSON requests with body data
+    if (data && typeof data === "object") {
+      headers["Content-Type"] = "application/json";
+    }
+
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: data ? JSON.stringify(data) : undefined,
+    });
+
+    return handleResponse(response, options.customErrorHandler);
+  }
+
+  return {
+    async get(path: string, options: RequestOptions = {}): Promise<any> {
+      return fetchJson("GET", path, undefined, options);
+    },
+
+    async post(
+      path: string,
+      data?: any,
+      options: RequestOptions = {},
+    ): Promise<any> {
+      return fetchJson("POST", path, data, options);
+    },
+
+    async put(
+      path: string,
+      data?: any,
+      options: RequestOptions = {},
+    ): Promise<any> {
+      return fetchJson("PUT", path, data, options);
+    },
+
+    async delete(path: string, options: RequestOptions = {}): Promise<any> {
+      return fetchJson("DELETE", path, undefined, options);
+    },
+
+    async poll(path: string, options: PollOptions = {}): Promise<any> {
+      const url = buildUrl(path, options.searchParams);
+      const headers = buildHeaders(options);
+
+      return pollUntilComplete({
+        fetch,
+        url,
+        headers,
+        maxAttempts: options.maxAttempts,
+        initialDelay: options.initialDelay,
+        maxDelay: options.maxDelay,
+        successStatus: options.successStatus,
+        pendingStatus: options.pendingStatus,
+        resultExtractor: options.resultExtractor,
+      });
+    },
+  };
+}

package/src/api/debug.ts

@@ -0,0 +1,58 @@
+/**
+ * Debug Logging Utilities
+ *
+ * This module provides debug logging capabilities for API requests and responses,
+ * including request timing and detailed logging of HTTP interactions.
+ */
+
+import type { DebugLogger } from "./types";
+
+export function createDebugLogger(enabled: boolean): DebugLogger {
+  if (!enabled) {
+    return () => {}; // No-op function when debug is disabled
+  }
+
+  return (message: string, data?: any) => {
+    console.log(`[Zapier SDK] ${message}`, data || "");
+  };
+}
+
+export function createDebugFetch(options: {
+  originalFetch: typeof globalThis.fetch;
+  debugLog: DebugLogger;
+}) {
+  const { originalFetch, debugLog } = options;
+  return async (input: RequestInfo | URL, options?: RequestInit) => {
+    const startTime = Date.now();
+
+    // Convert input to URL string for logging
+    const url = typeof input === "string" ? input : input.toString();
+    const method = options?.method || "GET";
+
+    debugLog(`→ ${method} ${url}`, {
+      headers: options?.headers,
+      body: options?.body ? JSON.parse(options.body as string) : undefined,
+    });
+
+    try {
+      const response = await originalFetch(input, options);
+      const duration = Date.now() - startTime;
+
+      debugLog(`← ${response.status} ${response.statusText} (${duration}ms)`, {
+        url,
+        method,
+        status: response.status,
+      });
+
+      return response;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      debugLog(`✖ Request failed (${duration}ms)`, {
+        url,
+        method,
+        error: error instanceof Error ? error.message : error,
+      });
+      throw error;
+    }
+  };
+}

package/src/api/index.ts

@@ -0,0 +1,83 @@
+/**
+ * Zapier API Client Module
+ *
+ * This module provides a centralized API layer for all HTTP interactions
+ * with Zapier's various APIs. It handles authentication, error handling,
+ * polling, and provides consistent patterns across all services.
+ */
+
+// Re-export all types
+export type {
+  // API Client Infrastructure Types
+  ApiClient,
+  ApiClientOptions,
+  RequestOptions,
+  PollOptions,
+  DebugLogger,
+  // API Response Model Types
+  Integration,
+  Action,
+  Trigger,
+  Field,
+  Choice,
+  ActionExecutionResult,
+  ActionField,
+  ActionFieldChoice,
+  NeedsRequest,
+  NeedsResponse,
+  Authentication,
+  AuthenticationsResponse,
+} from "./types";
+
+// Re-export authentication utilities
+export { isJwt, getAuthorizationHeader } from "./auth";
+
+// Re-export debug utilities
+export { createDebugLogger, createDebugFetch } from "./debug";
+
+// Re-export polling utilities
+export { pollUntilComplete } from "./polling";
+
+// Re-export the main client factory
+export { createZapierApi } from "./client";
+
+// Utility Functions
+export function generateRequestId(): string {
+  return Math.random().toString(36).substring(2) + Date.now().toString(36);
+}
+
+/**
+ * Utility function to get or create an API client for standalone functions
+ *
+ * @param config - Configuration that may include an existing API client
+ * @returns ApiClient instance
+ */
+export function getOrCreateApiClient(config: {
+  baseUrl?: string;
+  token?: string;
+  api?: import("./types").ApiClient;
+  debug?: boolean;
+  fetch?: typeof globalThis.fetch;
+}): import("./types").ApiClient {
+  const {
+    baseUrl = "https://zapier.com",
+    token = process.env.ZAPIER_TOKEN,
+    api: providedApi,
+    debug = false,
+    fetch: customFetch,
+  } = config;
+
+  // Use provided API client or create a new one
+  if (providedApi) {
+    return providedApi;
+  }
+
+  // Import createZapierApi locally to avoid circular imports
+  const { createZapierApi } = require("./client");
+  return createZapierApi({
+    baseUrl,
+    token,
+    debug,
+    fetch: customFetch,
+  });
+}

package/src/api/polling.ts

@@ -0,0 +1,56 @@
+/**
+ * Polling Utilities
+ *
+ * This module provides utilities for polling HTTP endpoints until completion,
+ * with configurable retry logic and exponential backoff.
+ */
+
+export async function pollUntilComplete(options: {
+  fetch: typeof globalThis.fetch;
+  url: string;
+  headers?: Record<string, string>;
+  maxAttempts?: number;
+  initialDelay?: number;
+  maxDelay?: number;
+  successStatus?: number;
+  pendingStatus?: number;
+  resultExtractor?: (response: any) => any;
+}): Promise<any> {
+  const {
+    fetch,
+    url,
+    headers = {},
+    maxAttempts = 30,
+    initialDelay = 50,
+    maxDelay = 1000,
+    successStatus = 200,
+    pendingStatus = 202,
+    resultExtractor = (response) => response,
+  } = options;
+
+  let delay = initialDelay;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const response = await fetch(url, { headers });
+
+    if (response.status === successStatus) {
+      // Success - extract and return results
+      const result = await response.json();
+      return resultExtractor(result);
+    } else if (response.status === pendingStatus) {
+      // Still processing - wait and retry
+      if (attempt < maxAttempts - 1) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * 2, maxDelay); // Exponential backoff
+        continue;
+      }
+    } else {
+      // Error occurred
+      throw new Error(
+        `Request failed: GET ${url} - ${response.status} ${response.statusText}`,
+      );
+    }
+  }
+
+  throw new Error(`Operation timed out after ${maxAttempts} attempts`);
+}

package/src/api/types.ts

@@ -0,0 +1,177 @@
+/**
+ * API Client Type Definitions
+ *
+ * This module contains all type definitions related to the Zapier API client,
+ * including configuration options, client interfaces, request/response types,
+ * and API response models.
+ */
+
+// ============================================================================
+// API Client Infrastructure Types
+// ============================================================================
+
+export interface ApiClientOptions {
+  baseUrl: string;
+  token?: string;
+  debug?: boolean;
+  fetch?: typeof globalThis.fetch;
+}
+
+export interface ApiClient {
+  get: (path: string, options?: RequestOptions) => Promise<any>;
+  post: (path: string, data?: any, options?: RequestOptions) => Promise<any>;
+  put: (path: string, data?: any, options?: RequestOptions) => Promise<any>;
+  delete: (path: string, options?: RequestOptions) => Promise<any>;
+  poll: (path: string, options?: PollOptions) => Promise<any>;
+}
+
+export interface RequestOptions {
+  headers?: Record<string, string>;
+  searchParams?: Record<string, string>;
+  authRequired?: boolean;
+  customErrorHandler?: (response: Response) => Error | undefined;
+}
+
+export interface PollOptions extends RequestOptions {
+  maxAttempts?: number;
+  initialDelay?: number;
+  maxDelay?: number;
+  successStatus?: number;
+  pendingStatus?: number;
+  resultExtractor?: (response: any) => any;
+}
+
+export interface DebugLogger {
+  (message: string, data?: any): void;
+}
+
+// ============================================================================
+// API Response Models
+// ============================================================================
+
+export interface Integration {
+  key: string;
+  name: string;
+  description: string;
+  version: string;
+  category?: string;
+  actions: Action[];
+  triggers: Trigger[];
+  current_implementation_id?: string;
+}
+
+export interface Action {
+  key: string;
+  name: string;
+  description: string;
+  appKey: string;
+  type: "create" | "update" | "search" | "delete" | "read";
+  inputFields: Field[];
+  outputFields: Field[];
+}
+
+export interface Trigger {
+  key: string;
+  name: string;
+  description: string;
+  appKey: string;
+  type: "instant" | "polling" | "webhook";
+  outputFields: Field[];
+}
+
+export interface Field {
+  key: string;
+  label: string;
+  type:
+    | "string"
+    | "number"
+    | "boolean"
+    | "datetime"
+    | "file"
+    | "object"
+    | "array";
+  required: boolean;
+  description?: string;
+  choices?: Choice[];
+}
+
+export interface Choice {
+  value: string | number;
+  label: string;
+}
+
+export interface ActionExecutionResult {
+  success: boolean;
+  data?: any;
+  error?: string;
+  metadata?: {
+    executionTime?: number;
+    requestId?: string;
+  };
+}
+
+export interface ActionField {
+  key: string;
+  label?: string;
+  required: boolean;
+  type?: string;
+  helpText?: string;
+  helpTextHtml?: string;
+  choices?: ActionFieldChoice[];
+  default?: string;
+  placeholder?: string;
+  computed?: boolean;
+  customField?: boolean;
+  dependsOn?: string[];
+  format?: string;
+  inputFormat?: string[];
+}
+
+export interface ActionFieldChoice {
+  value: string | number;
+  label: string;
+}
+
+export interface NeedsRequest {
+  selected_api: string;
+  action: string;
+  type_of: string;
+  authentication_id?: number;
+  params?: Record<string, any>;
+}
+
+export interface NeedsResponse {
+  success: boolean;
+  needs?: ActionField[];
+  errors?: string[];
+}
+
+export interface Authentication {
+  id: number;
+  date: string;
+  lastchanged?: string;
+  account_id: number;
+  customuser_id?: number;
+  selected_api: string;
+  destination_selected_api?: string | null;
+  is_invite_only: boolean;
+  is_private: boolean;
+  shared_with_all: boolean;
+  is_stale?: string;
+  is_shared?: string;
+  marked_stale_at?: string | null;
+  label?: string | null;
+  identifier?: string | null;
+  title?: string | null;
+  url?: string;
+  groups?: string;
+  members?: string;
+  permissions?: Record<string, boolean>;
+}
+
+export interface AuthenticationsResponse {
+  count: number;
+  next?: string | null;
+  previous?: string | null;
+  results: Authentication[];
+}

package/src/functions/{bundleCode.ts → bundleCode/index.ts}

@@ -1,11 +1,4 @@
-export interface BundleCodeOptions {
-  input: string;
-  output?: string;
-  target?: string;
-  cjs?: boolean;
-  minify?: boolean;
-  string?: boolean;
-}
+import type { BundleCodeOptions } from "./schemas";
 
 /**
  * Bundle TypeScript code into executable JavaScript

package/src/functions/bundleCode/info.ts

@@ -0,0 +1,9 @@
+import { bundleCode } from "./index";
+import { BundleCodeSchema } from "./schemas";
+
+// Function registry info - imports both function and schema
+export const bundleCodeInfo = {
+  name: bundleCode.name,
+  inputSchema: BundleCodeSchema,
+  implementation: bundleCode,
+};