@zapier/zapier-sdk 0.13.6 → 0.13.8

package/src/api/types.ts

@@ -1,152 +0,0 @@
-/**
- * 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 response model types are inferred from Zod schemas defined in api/schemas.ts
- * to ensure a single source of truth and eliminate duplication.
- */
-
-import type { SdkEvent } from "../types/events";
-import type { z } from "zod";
-import type {
-  NeedChoicesSchema,
-  NeedSchema,
-  ActionLinksSchema,
-  ActionPermissionsSchema,
-  ActionSchema,
-  ChoiceSchema,
-  FieldSchema,
-  ActionExecutionResultSchema,
-  ActionFieldChoiceSchema,
-  ActionFieldSchema,
-  AuthenticationSchema,
-  AuthenticationsResponseSchema,
-  UserProfileSchema,
-  AppSchema,
-  NeedsRequestSchema,
-  NeedsResponseSchema,
-  ImplementationSchema,
-  ImplementationsResponseSchema,
-  ImplementationMetaSchema,
-  ImplementationsMetaResponseSchema,
-  ServiceSchema,
-  ServicesResponseSchema,
-  NeedChoicesRequestSchema,
-  NeedChoicesResponseSchema,
-  NeedChoicesResponseMetaSchema,
-  NeedChoicesResponseLinksSchema,
-} from "./schemas";
-
-// ============================================================================
-// API Client Infrastructure Types
-// ============================================================================
-
-export interface ApiClientOptions {
-  baseUrl: string;
-  token?: string;
-  getToken?: () => Promise<string | undefined>;
-  debug?: boolean;
-  fetch?: typeof globalThis.fetch;
-  onEvent?: (event: SdkEvent) => void;
-}
-
-export interface ApiClient {
-  get: <T = unknown>(path: string, options?: RequestOptions) => Promise<T>;
-  post: <T = unknown>(
-    path: string,
-    data?: unknown,
-    options?: RequestOptions,
-  ) => Promise<T>;
-  put: <T = unknown>(
-    path: string,
-    data?: unknown,
-    options?: RequestOptions,
-  ) => Promise<T>;
-  delete: <T = unknown>(path: string, options?: RequestOptions) => Promise<T>;
-  poll: <T = unknown>(path: string, options?: PollOptions) => Promise<T>;
-  fetch: (
-    path: string,
-    init?: RequestInit & {
-      searchParams?: Record<string, string>;
-      authRequired?: boolean;
-    },
-  ) => Promise<Response>;
-}
-
-export interface RequestOptions {
-  headers?: Record<string, string>;
-  searchParams?: Record<string, string>;
-  authRequired?: boolean;
-  customErrorHandler?: (errorInfo: {
-    status: number;
-    statusText: string;
-    data: unknown;
-  }) => Error | undefined;
-}
-
-export interface PollOptions extends RequestOptions {
-  initialDelay?: number;
-  timeoutMs?: number;
-  successStatus?: number;
-  pendingStatus?: number;
-  resultExtractor?: (response: unknown) => unknown;
-}
-
-export interface DebugLogger {
-  (message: string, data?: unknown): void;
-}
-
-// ============================================================================
-// API Response Models (inferred from Zod schemas)
-// ============================================================================
-
-// Basic building blocks
-export type NeedChoices = z.infer<typeof NeedChoicesSchema>;
-export type Need = z.infer<typeof NeedSchema>;
-export type ActionLinks = z.infer<typeof ActionLinksSchema>;
-export type ActionPermissions = z.infer<typeof ActionPermissionsSchema>;
-export type Action = z.infer<typeof ActionSchema>;
-export type Choice = z.infer<typeof ChoiceSchema>;
-export type Field = z.infer<typeof FieldSchema>;
-export type ActionExecutionResult = z.infer<typeof ActionExecutionResultSchema>;
-export type ActionFieldChoice = z.infer<typeof ActionFieldChoiceSchema>;
-export type ActionField = z.infer<typeof ActionFieldSchema>;
-
-// Main API entities
-export type Authentication = z.infer<typeof AuthenticationSchema>;
-export type AuthenticationsResponse = z.infer<
-  typeof AuthenticationsResponseSchema
->;
-export type UserProfile = z.infer<typeof UserProfileSchema>;
-export type App = z.infer<typeof AppSchema>;
-export type Service = z.infer<typeof ServiceSchema>;
-export type ServicesResponse = z.infer<typeof ServicesResponseSchema>;
-
-// Request/Response types
-export type NeedsRequest = z.infer<typeof NeedsRequestSchema>;
-export type NeedsResponse = z.infer<typeof NeedsResponseSchema>;
-
-// Implementation types
-export type Implementation = z.infer<typeof ImplementationSchema>;
-export type ImplementationsResponse = z.infer<
-  typeof ImplementationsResponseSchema
->;
-
-// Implementation Meta types (lightweight)
-export type ImplementationMeta = z.infer<typeof ImplementationMetaSchema>;
-export type ImplementationsMetaResponse = z.infer<
-  typeof ImplementationsMetaResponseSchema
->;
-
-// Need Choices types (for listInputFieldChoices functionality)
-export type NeedChoicesRequest = z.infer<typeof NeedChoicesRequestSchema>;
-export type NeedChoicesResponse = z.infer<typeof NeedChoicesResponseSchema>;
-export type NeedChoicesResponseMeta = z.infer<
-  typeof NeedChoicesResponseMetaSchema
->;
-export type NeedChoicesResponseLinks = z.infer<
-  typeof NeedChoicesResponseLinksSchema
->;

package/src/auth.ts

@@ -1,72 +0,0 @@
-/**
- * SDK Authentication Utilities
- *
- * This module provides SDK-level authentication utilities focused
- * solely on token acquisition. CLI-specific functionality like login/logout
- * is handled by the @zapier/zapier-sdk-cli-login package.
- */
-
-// Import event types from common location
-import type { EventCallback } from "./types/events";
-
-// Re-export for backward compatibility
-export type {
-  SdkEvent,
-  AuthEvent,
-  ApiEvent,
-  LoadingEvent,
-  EventCallback,
-} from "./types/events";
-
-// Options interfaces for auth functions
-export interface AuthOptions {
-  onEvent?: EventCallback;
-  fetch?: typeof globalThis.fetch;
-}
-
-/**
- * Gets the ZAPIER_TOKEN from environment variables.
- * Returns undefined if not set.
- */
-export function getTokenFromEnv(): string | undefined {
-  return process.env.ZAPIER_TOKEN;
-}
-
-/**
- * Attempts to get a token by optionally importing from CLI login package.
- * This provides a graceful fallback when the CLI login package is not available.
- *
- * Returns undefined if no valid token is found or CLI package is not available.
- */
-export async function getTokenFromCliLogin(
-  options: AuthOptions = {},
-): Promise<string | undefined> {
-  try {
-    // Dynamically import the CLI login package if available
-    const { getToken } = await import("@zapier/zapier-sdk-cli-login");
-    return await getToken(options);
-  } catch {
-    // CLI login package is not available, return undefined
-    return undefined;
-  }
-}
-
-/**
- * Attempts to get a token with the following precedence:
- * 1. ZAPIER_TOKEN environment variable
- * 2. CLI login package (if available) with auto-refresh
- *
- * Returns undefined if no valid token is found.
- */
-export async function getTokenFromEnvOrConfig(
-  options: AuthOptions = {},
-): Promise<string | undefined> {
-  // First priority: environment variable
-  const envToken = getTokenFromEnv();
-  if (envToken) {
-    return envToken;
-  }
-
-  // Second priority: CLI login package (if available)
-  return getTokenFromCliLogin(options);
-}

package/src/constants.ts

@@ -1,16 +0,0 @@
-/**
- * SDK Constants
- *
- * This module contains shared constants used throughout the SDK.
- */
-
-/**
- * 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/src/index.ts

@@ -1,111 +0,0 @@
-// Export everything from types and plugins
-export * from "./types/domain";
-export * from "./types/functions";
-export * from "./types/properties";
-export * from "./types/errors";
-export * from "./plugins/apps";
-export * from "./plugins/fetch";
-export * from "./plugins/listApps";
-export * from "./plugins/listActions";
-export * from "./plugins/listInputFields";
-export * from "./plugins/listAuthentications";
-export * from "./plugins/getApp";
-export * from "./plugins/getAction";
-export * from "./plugins/getAuthentication";
-export * from "./plugins/findFirstAuthentication";
-export * from "./plugins/findUniqueAuthentication";
-export * from "./plugins/runAction";
-export * from "./plugins/request";
-export * from "./plugins/manifest";
-export * from "./plugins/getProfile";
-export * from "./plugins/api";
-
-// Export API types directly (no longer re-exported from domain)
-export type {
-  Action,
-  App,
-  Need,
-  Field,
-  Choice,
-  ActionExecutionResult,
-  ActionField,
-  ActionFieldChoice,
-  NeedsRequest,
-  NeedsResponse,
-  Authentication,
-  AuthenticationsResponse,
-  UserProfile,
-} from "./api/types";
-
-// Export schema utilities for CLI
-export { isPositional, PositionalMetadata } from "./utils/schema-utils";
-export { createFunction } from "./utils/function-utils";
-export type { FormattedItem, FormatMetadata } from "./utils/schema-utils";
-
-// Export string utilities
-export { toSnakeCase, toTitleCase } from "./utils/string-utils";
-
-// Export resolver utilities for CLI
-export * from "./resolvers";
-
-// Export auth utilities for CLI use
-export * from "./auth";
-
-// All functions now available through the plugin system via createZapierSdk()
-// Export plugin schemas for external use
-export {
-  RelayRequestSchema,
-  RelayFetchSchema,
-} from "./plugins/request/schemas";
-
-// Export the main combined SDK and new flexible SDK creator
-export {
-  createZapierSdk,
-  createZapierSdkWithoutRegistry,
-  createSdk,
-  ZapierSdkOptions,
-} from "./sdk";
-
-// Export SDK types from types (not sdk.ts to avoid circular imports)
-export type { FunctionRegistryEntry } from "./types/sdk";
-
-// Export plugin utilities and SDK types
-export type {
-  Plugin,
-  PluginProvides,
-  PluginDependencies,
-  PluginOptions,
-  GetSdkType,
-  GetContextType,
-  Sdk,
-} from "./types/plugin";
-
-// Export registry plugin for manual use
-export { registryPlugin } from "./plugins/registry";
-
-// Export ZapierSdk from sdk.ts (it's now ReturnType<typeof createZapierSdk>)
-export type { ZapierSdk } from "./types/sdk";
-
-// Export event types and utilities for external packages
-export type { BaseEvent } from "./types/telemetry-events";
-export type {
-  EventEmissionContext,
-  EventContext,
-  ApplicationLifecycleEventData,
-  EnhancedErrorEventData,
-} from "./plugins/eventEmission";
-export {
-  generateEventId,
-  getCurrentTimestamp,
-  getReleaseId,
-  getOsInfo,
-  getPlatformVersions,
-  isCi,
-  getCiPlatform,
-  getMemoryUsage,
-  getCpuTime,
-  buildApplicationLifecycleEvent,
-  buildErrorEventWithContext,
-  buildErrorEvent,
-  createBaseEvent,
-} from "./plugins/eventEmission";

package/src/plugins/api/index.ts

@@ -1,43 +0,0 @@
-import { createZapierApi } from "../../api";
-import type { ApiClient } from "../../api/types";
-import type { BaseSdkOptions } from "../../types/sdk";
-import type { Plugin } from "../../types/plugin";
-
-export interface ApiPluginOptions extends BaseSdkOptions {}
-
-// API plugin only provides context, no SDK methods
-export interface ApiPluginProvides {
-  context: {
-    api: ApiClient;
-  };
-}
-
-// API plugin requires no context and provides api in context
-export const apiPlugin: Plugin<{}, {}, ApiPluginProvides> = (params) => {
-  // Extract all options - everything passed to the plugin
-  const {
-    fetch: customFetch = globalThis.fetch,
-    baseUrl = "https://zapier.com",
-    token,
-    getToken,
-    onEvent,
-    debug = false,
-  } = params.context.options;
-
-  // Create the API client - it will handle token resolution internally
-  const api = createZapierApi({
-    baseUrl,
-    token,
-    getToken,
-    debug,
-    fetch: customFetch,
-    onEvent,
-  });
-
-  // Return flat structure with context only
-  return {
-    context: {
-      api, // Provide API client in context for other plugins to use
-    },
-  };
-};

package/src/plugins/apps/index.ts

@@ -1,203 +0,0 @@
-import type {
-  ActionExecutionOptions,
-  ActionProxy,
-  AppFactoryInput,
-} from "./schemas";
-import { ActionExecutionInputSchema, AppFactoryInputSchema } from "./schemas";
-import { ZapierValidationError } from "../../types/errors";
-import type { Plugin, GetSdkType } from "../../types/plugin";
-import type { FetchPluginProvides } from "../fetch/index";
-import type { RunActionPluginProvides } from "../runAction/index";
-import { ActionResultItemSchema } from "../../schemas/Run";
-
-export interface AppsPluginProvides {
-  apps: ActionProxy;
-}
-
-interface AppsPluginOptions {
-  sdk: GetSdkType<FetchPluginProvides & RunActionPluginProvides>;
-}
-
-function createActionFunction(
-  appKey: string,
-  actionType: string,
-  actionKey: string,
-  options: AppsPluginOptions,
-  pinnedAuthId?: number,
-) {
-  return (actionOptions: ActionExecutionOptions = {}): any => {
-    const { sdk } = options;
-    const { inputs, authenticationId: providedAuthenticationId } =
-      actionOptions;
-
-    // Use pinned auth ID first, then provided auth ID
-    const authenticationId = pinnedAuthId || providedAuthenticationId;
-
-    if (!authenticationId) {
-      throw new ZapierValidationError(
-        `Authentication ID is required. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }) or provide authenticationId in the action call.`,
-      );
-    }
-
-    // Call sdk.runAction with the resolved parameters
-    return sdk.runAction({
-      appKey,
-      actionType: actionType as any,
-      actionKey,
-      inputs,
-      authenticationId,
-    });
-  };
-}
-
-function createActionTypeProxy(
-  appKey: string,
-  actionType: string,
-  options: AppsPluginOptions,
-  pinnedAuthId?: number,
-) {
-  // Special handling for "fetch" action type
-  if (actionType === "fetch") {
-    return async (
-      url: string | URL,
-      init?: RequestInit & {
-        authenticationId?: number;
-        callbackUrl?: string;
-        authenticationTemplate?: string;
-      },
-    ) => {
-      const { sdk } = options;
-
-      // Use pinned auth ID first, then provided auth ID
-      const authenticationId = pinnedAuthId || init?.authenticationId;
-
-      if (!authenticationId) {
-        throw new ZapierValidationError(
-          `Authentication ID is required for fetch. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }).fetch(...) or provide authenticationId in the fetch call.`,
-        );
-      }
-
-      // Call sdk.fetch with the resolved authenticationId
-      return sdk.fetch(url, {
-        ...init,
-        authenticationId,
-      });
-    };
-  }
-
-  return new Proxy(
-    {},
-    {
-      get(_, actionKey) {
-        if (typeof actionKey === "string") {
-          return createActionFunction(
-            appKey,
-            actionType,
-            actionKey,
-            options,
-            pinnedAuthId,
-          );
-        }
-        return undefined;
-      },
-    },
-  );
-}
-
-function createPinnedAppProxy(
-  appKey: string,
-  options: AppsPluginOptions,
-  pinnedAuthId: number,
-) {
-  return new Proxy(
-    {},
-    {
-      get(_, actionType) {
-        if (typeof actionType === "string") {
-          return createActionTypeProxy(
-            appKey,
-            actionType,
-            options,
-            pinnedAuthId,
-          );
-        }
-        return undefined;
-      },
-    },
-  );
-}
-
-function createAppProxy(appKey: string, options: AppsPluginOptions) {
-  // Create the factory function that returns a pinned version
-  const appFactory = (factoryOptions: AppFactoryInput) => {
-    return createPinnedAppProxy(
-      appKey,
-      options,
-      factoryOptions.authenticationId,
-    );
-  };
-
-  // Add properties for direct usage (backward compatibility)
-  return new Proxy(appFactory, {
-    get(_, actionType) {
-      if (typeof actionType === "string") {
-        return createActionTypeProxy(appKey, actionType, options);
-      }
-      return undefined;
-    },
-  });
-}
-
-function createAppsProxy(options: AppsPluginOptions): ActionProxy {
-  // Create a proxy object that intercepts property access
-  const appsProxy = new Proxy({} as ActionProxy, {
-    get(_, prop) {
-      if (typeof prop === "string") {
-        // First level: App names (e.g., 'slack')
-        return createAppProxy(prop, options);
-      }
-      return undefined;
-    },
-  });
-
-  return appsProxy;
-}
-
-// Direct plugin function - takes options + sdk + context in one object
-export const appsPlugin: Plugin<
-  GetSdkType<FetchPluginProvides & RunActionPluginProvides>, // requires fetch + runAction in SDK
-  {}, // no context requirements
-  AppsPluginProvides
-> = ({ sdk }) => {
-  // Return flat structure - apps goes directly to SDK
-  return {
-    apps: createAppsProxy({ sdk }),
-    context: {
-      meta: {
-        "apps.{appKey}": {
-          categories: ["app"],
-          packages: ["sdk"],
-          type: "function",
-          inputSchema: AppFactoryInputSchema,
-          returnType: "AppProxy",
-        },
-        "apps.{appKey}.{actionType}.{actionKey}": {
-          categories: ["app"],
-          packages: ["sdk"],
-          type: "list",
-          inputSchema: ActionExecutionInputSchema,
-          itemType: "ActionResult",
-          outputSchema: ActionResultItemSchema,
-        },
-      },
-    },
-  };
-};
-
-// Export types for use in generated code
-export type { ActionExecutionOptions } from "./schemas";
-export type { ActionExecutionResult } from "../../api/types";
-
-// Interface for generated apps - will be augmented by generated .d.ts files
-// This interface will contain only the specifically typed apps
-export interface ZapierSdkApps {}

package/src/plugins/apps/schemas.ts

@@ -1,64 +0,0 @@
-import { z } from "zod";
-
-export const ActionExecutionInputSchema = z
-  .object({
-    inputs: z.record(z.unknown()).optional(),
-    authenticationId: z.number().optional(),
-  })
-  .describe(
-    "Execute an action with the given inputs for the bound app, as an alternative to runAction",
-  );
-
-// Apps plugin-specific execution options
-export type ActionExecutionOptions = z.infer<typeof ActionExecutionInputSchema>;
-
-export const AppFactoryInputSchema = z
-  .object({
-    authenticationId: z.number(),
-  })
-  .describe("Bind an authentication ID to an app");
-
-export type AppFactoryInput = z.infer<typeof AppFactoryInputSchema>;
-
-// Base action type proxy for regular actions
-interface BaseActionTypeProxy {
-  [action: string]: (options?: ActionExecutionOptions) => Promise<{
-    data: any[];
-    nextCursor?: string;
-  }> &
-    AsyncIterable<{ data: any[]; nextCursor?: string }> & {
-      items(): AsyncIterable<any>;
-    };
-}
-
-// Special fetch function type
-interface FetchActionType {
-  fetch: (
-    url: string | URL,
-    init?: RequestInit & {
-      authenticationId?: number;
-      callbackUrl?: string;
-      authenticationTemplate?: string;
-    },
-  ) => Promise<Response>;
-}
-
-// Combined action type proxy
-type ActionTypeProxy = BaseActionTypeProxy & Partial<FetchActionType>;
-
-interface AppProxy {
-  [type: string]: ActionTypeProxy;
-}
-
-interface AppFactory {
-  (options: AppFactoryInput): AppProxy;
-}
-
-// An app can be both a factory function and have properties for direct access
-type AppProxyWithFactory = AppFactory & AppProxy;
-
-export interface ActionProxy {
-  [app: string]: AppProxyWithFactory;
-}
-
-// Note: AppsPluginSdkExtension removed - now using AppsPluginProvides in index.ts