@zapier/zapier-sdk 0.4.1 → 0.5.0

package/src/functions/listAuthentications/index.ts

@@ -1,162 +0,0 @@
-import { getOrCreateApiClient } from "../../api";
-import type {
-  Authentication,
-  AuthenticationsResponse,
-} from "../../types/domain";
-import { getApp } from "../getApp";
-import type { ListAuthenticationsOptions } from "./schemas";
-
-/**
- * List available authentications with optional filtering
- *
- * This function can be used standalone without instantiating a full SDK,
- * which enables better tree-shaking in applications that only need this functionality.
- *
- * @param options - Filtering, pagination, and API configuration options
- * @returns Promise<Authentication[]> with pagination metadata
- */
-export async function listAuthentications(
-  options: Partial<ListAuthenticationsOptions> = {},
-): Promise<Authentication[]> {
-  const api = getOrCreateApiClient(options);
-
-  // Local function to handle the actual API fetching
-  const listAuthenticationsInternal = async (
-    options: ListAuthenticationsOptions = {},
-  ): Promise<Authentication[]> => {
-    // Build search parameters
-    const searchParams: Record<string, string> = {};
-
-    // Handle appKey filtering by getting the selected_api first
-    if (options.appKey) {
-      try {
-        // Use the standalone getApp function
-        const app = await getApp({
-          appKey: options.appKey,
-          api,
-          token: options.token,
-          baseUrl: options.baseUrl,
-          debug: options.debug,
-          fetch: options.fetch,
-        });
-        const selectedApi = app.current_implementation_id;
-        if (selectedApi) {
-          // Use versionless_selected_api to find auths across all app versions
-          // Extract the base name without the version (e.g., "SlackCLIAPI" from "SlackCLIAPI@1.21.1")
-          const versionlessApi = selectedApi.split("@")[0];
-          searchParams.versionless_selected_api = versionlessApi;
-        }
-      } catch (error) {
-        // If it's an AppNotFoundError, re-throw it
-        if (error instanceof Error && error.name === "AppNotFoundError") {
-          throw error;
-        }
-        // For other errors, continue without app filtering
-        console.warn(
-          `Warning: Could not filter by app ${options.appKey}:`,
-          error instanceof Error ? error.message : "Unknown error",
-        );
-      }
-    }
-
-    // Add other query parameters if provided
-    // Use title as search if no explicit search provided
-    if (options.search) {
-      searchParams.search = options.search;
-    } else if (options.title) {
-      searchParams.search = options.title;
-    }
-    if (options.account_id) {
-      searchParams.account_id = options.account_id;
-    }
-    if (options.owner) {
-      searchParams.owner = options.owner;
-    }
-    if (options.limit) {
-      searchParams.limit = options.limit.toString();
-    }
-    if (options.offset) {
-      searchParams.offset = options.offset.toString();
-    }
-
-    const data: AuthenticationsResponse = await api.get(
-      "/api/v4/authentications/",
-      {
-        searchParams,
-        customErrorHandler: (response) => {
-          if (response.status === 401) {
-            return new Error(
-              `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${response.status})`,
-            );
-          }
-          if (response.status === 403) {
-            return new Error(
-              `Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${response.status})`,
-            );
-          }
-          return undefined;
-        },
-      },
-    );
-
-    // Transform API response
-    let auths = data.results || [];
-
-    // Coerce title from label if title is missing (API cleanup)
-    auths = auths.map((auth) => ({
-      ...auth,
-      title: auth.title || (auth as any).label || undefined,
-    }));
-
-    // Filter by exact title match if specified
-    if (options.title) {
-      auths = auths.filter((auth) => auth.title === options.title);
-    }
-
-    // Add pagination metadata to the response
-    if (auths.length > 0) {
-      (auths as any).__pagination = {
-        count: data.count,
-        hasNext: !!data.next,
-        hasPrevious: !!data.previous,
-        nextUrl: data.next,
-        previousUrl: data.previous,
-      };
-    }
-
-    return auths;
-  };
-
-  // If a limit is provided and no specific owner filter, prioritize owned auths
-  if (options.limit && options.owner === undefined) {
-    // First get owned auths
-    const ownedAuths = await listAuthenticationsInternal({
-      ...options,
-      owner: "me",
-    });
-
-    // If we have enough owned auths, just slice and return
-    if (ownedAuths.length >= options.limit) {
-      return ownedAuths.slice(0, options.limit);
-    }
-
-    // Get all auths up to the original limit to fill remaining slots
-    const allAuths = await listAuthenticationsInternal({
-      ...options,
-      owner: undefined,
-    });
-
-    // Filter out auths the user already owns to avoid duplicates
-    const ownedAuthenticationIds = new Set(ownedAuths.map((auth) => auth.id));
-    const additionalAuths = allAuths.filter(
-      (auth) => !ownedAuthenticationIds.has(auth.id),
-    );
-
-    // Combine and slice to the requested limit
-    const combined = [...ownedAuths, ...additionalAuths];
-    return combined.slice(0, options.limit);
-  }
-
-  // Standard implementation for non-prioritized requests
-  return listAuthenticationsInternal(options);
-}

package/src/functions/listAuthentications/info.ts

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

package/src/functions/listAuthentications/schemas.ts

@@ -1,50 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  LimitPropertySchema,
-  OffsetPropertySchema,
-} from "../../types/properties";
-import { withOutputSchema } from "../../schema-utils";
-import { AuthItemSchema } from "../../schemas/Auth";
-import type { Authentication, FunctionOptions } from "../../types/domain";
-
-// Pure Zod schema - no resolver metadata!
-export const ListAuthenticationsSchema = withOutputSchema(
-  z
-    .object({
-      appKey: AppKeyPropertySchema.optional().describe(
-        "App slug to get authentications for (e.g., 'slack', 'github')",
-      ),
-      search: z
-        .string()
-        .optional()
-        .describe("Search term to filter authentications by title"),
-      title: z
-        .string()
-        .optional()
-        .describe("Filter authentications by exact title match"),
-      account_id: z.string().optional().describe("Filter by account ID"),
-      owner: z.string().optional().describe("Filter by owner"),
-      limit: LimitPropertySchema.optional().describe(
-        "Maximum number of items to return (1-200)",
-      ),
-      offset: OffsetPropertySchema.optional().describe(
-        "Number of items to skip for pagination",
-      ),
-    })
-    .describe("List available authentications with optional filtering"),
-  AuthItemSchema,
-);
-
-// Type inferred from schema + function config
-export type ListAuthenticationsOptions = z.infer<
-  typeof ListAuthenticationsSchema
-> &
-  FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface ListAuthenticationsSdkFunction {
-  listAuthentications: (
-    options?: Partial<ListAuthenticationsOptions>,
-  ) => Promise<Authentication[]>;
-}

package/src/functions/listFields/index.ts

@@ -1,86 +0,0 @@
-import { getOrCreateApiClient } from "../../api";
-import type {
-  ActionField,
-  NeedsRequest,
-  NeedsResponse,
-} from "../../types/domain";
-import { getApp } from "../getApp";
-import type { ListFieldsOptions } from "./schemas";
-
-/**
- * List available fields for an action
- *
- * This function can be used standalone without instantiating a full SDK,
- * which enables better tree-shaking in applications that only need this functionality.
- *
- * @param options - Action details, authentication ID, params, and API configuration options
- * @returns Promise<ActionField[]>
- */
-export async function listFields(
-  options: ListFieldsOptions,
-): Promise<ActionField[]> {
-  const api = getOrCreateApiClient(options);
-
-  // Extract parameters
-  const { appKey, actionKey, actionType, authenticationId, params } = options;
-
-  // Use the standalone getApp function
-  const appData = await getApp({
-    appKey,
-    api,
-    token: options.token,
-    baseUrl: options.baseUrl,
-    debug: options.debug,
-    fetch: options.fetch,
-  });
-  const selectedApi = appData.current_implementation_id;
-
-  if (!selectedApi) {
-    throw new Error("No current_implementation_id found for app");
-  }
-
-  // Build needs request
-  const needsRequest: NeedsRequest = {
-    selected_api: selectedApi,
-    action: actionKey,
-    type_of: actionType,
-    authentication_id: authenticationId,
-    params: params || {},
-  };
-
-  const needsData: NeedsResponse = await api.post(
-    "/api/v4/implementations/needs/",
-    needsRequest,
-  );
-
-  if (!needsData.success) {
-    throw new Error(
-      `Failed to get action fields: ${
-        needsData.errors?.join(", ") || "Unknown error"
-      }`,
-    );
-  }
-
-  // Transform API response to our ActionField interface
-  return (needsData.needs || []).map((need: any) => ({
-    key: need.key,
-    label: need.label,
-    required: need.required || false,
-    type: need.type,
-    helpText: need.help_text,
-    helpTextHtml: need.help_text_html,
-    choices: need.choices?.map((choice: any) => ({
-      value: choice.value,
-      label: choice.label,
-    })),
-    default: need.default,
-    placeholder: need.placeholder,
-    computed: need.computed,
-    customField: need.custom_field,
-    dependsOn: need.depends_on,
-    format: need.format,
-    inputFormat: need.input_format,
-  }));
-}
-
-// No registry info here - moved to info.ts for proper tree-shaking

package/src/functions/listFields/info.ts

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

package/src/functions/listFields/schemas.ts

@@ -1,36 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  ActionTypePropertySchema,
-  ActionKeyPropertySchema,
-  AuthenticationIdPropertySchema,
-  ParamsPropertySchema,
-} from "../../types/properties";
-import { withOutputSchema } from "../../schema-utils";
-import { FieldItemSchema } from "../../schemas/Field";
-import type { ActionField, FunctionOptions } from "../../types/domain";
-
-// Pure Zod schema - no resolver metadata!
-export const ListFieldsSchema = withOutputSchema(
-  z
-    .object({
-      appKey: AppKeyPropertySchema,
-      actionType: ActionTypePropertySchema,
-      actionKey: ActionKeyPropertySchema,
-      authenticationId: AuthenticationIdPropertySchema.optional(),
-      params: ParamsPropertySchema.optional().describe(
-        "Additional parameters that may affect available fields",
-      ),
-    })
-    .describe("Get the input fields required for a specific action"),
-  FieldItemSchema,
-);
-
-// Type inferred from schema + function config
-export type ListFieldsOptions = z.infer<typeof ListFieldsSchema> &
-  FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface ListFieldsSdkFunction {
-  listFields: (options: ListFieldsOptions) => Promise<ActionField[]>;
-}

package/src/functions/request/index.ts

@@ -1,150 +0,0 @@
-import { getOrCreateApiClient } from "../../api";
-import type { FunctionOptions } from "../../types/domain";
-
-export interface RelayRequestOptions {
-  /** HTTP method */
-  method?: string;
-  /** Request body (can be string, FormData, Blob, etc.) */
-  body?: BodyInit | null;
-  /** Request headers */
-  headers?: HeadersInit;
-  /** Zapier authentication ID to use for the request */
-  authenticationId?: number;
-  /** URL to send async response to (makes request async) */
-  callbackUrl?: string;
-  /** Optional JSON string authentication template to bypass Notary lookup */
-  authenticationTemplate?: string;
-}
-
-// Legacy type alias
-export type RelayFetchOptions = RelayRequestOptions;
-
-export interface RelayFetchConfig extends FunctionOptions {
-  /** Event callback function */
-  onEvent?: (event: any) => void;
-}
-
-/**
- * Transforms full URLs into Relay format: /relay/{domain}/{path}
- *
- * @param url - The full URL to transform (e.g., "https://api.github.com/user")
- * @returns The relay path format (e.g., "/relay/api.github.com/user")
- */
-function transformUrlToRelayPath(url: string | URL): string {
-  const targetUrl = new URL(url);
-
-  // Build the Relay path: /relay/{domain}{pathname}{search}{hash}
-  const relayPath = `/relay/${targetUrl.hostname}${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
-
-  return relayPath;
-}
-
-/**
- * Fetch function that can make requests to external APIs through Zapier's Relay service
- *
- * This function takes full URLs (like https://api.github.com/user) and transforms them
- * into the relay format (/relay/api.github.com/user) for the API client to route
- * to relay.zapier.com.
- *
- * @param url - The full URL to fetch
- * @param options - Fetch options with additional Relay-specific parameters
- * @param config - SDK configuration options
- * @returns Promise<Response> - The response from the request
- */
-/**
- * Schema-compatible wrapper function for the request functionality
- */
-export async function request(
-  options: {
-    url: string;
-    method?: string;
-    body?: BodyInit | null;
-    headers?: HeadersInit;
-    authenticationId?: number;
-    callbackUrl?: string;
-    authenticationTemplate?: string;
-  } & FunctionOptions,
-): Promise<Response> {
-  const {
-    url,
-    method = "GET",
-    body,
-    headers,
-    authenticationId,
-    callbackUrl,
-    authenticationTemplate,
-    ...config
-  } = options;
-
-  return relayFetch(
-    url,
-    {
-      method,
-      body,
-      headers,
-      authenticationId,
-      callbackUrl,
-      authenticationTemplate,
-    },
-    config,
-  );
-}
-
-/**
- * Internal fetch implementation
- */
-export async function relayFetch(
-  url: string | URL,
-  options: RelayRequestOptions = {},
-  config: RelayFetchConfig = {},
-): Promise<Response> {
-  const api = getOrCreateApiClient(config);
-
-  // Extract Relay-specific options
-  const {
-    authenticationId,
-    callbackUrl,
-    authenticationTemplate,
-    method = "GET",
-    body,
-    ...fetchOptions
-  } = options;
-
-  // Transform full URL to relay path format
-  const relayPath = transformUrlToRelayPath(url);
-
-  // Build headers for the request
-  const headers: Record<string, string> = {};
-
-  // Copy existing headers
-  if (fetchOptions.headers) {
-    const headerEntries =
-      fetchOptions.headers instanceof Headers
-        ? Array.from(fetchOptions.headers.entries())
-        : Object.entries(fetchOptions.headers);
-
-    for (const [key, value] of headerEntries) {
-      headers[key] = value;
-    }
-  }
-
-  // Add Relay-specific headers
-  if (authenticationId) {
-    headers["X-Relay-Authentication-Id"] = authenticationId.toString();
-  }
-
-  if (callbackUrl) {
-    headers["X-Relay-Callback-Url"] = callbackUrl;
-  }
-
-  if (authenticationTemplate) {
-    headers["X-Authentication-Template"] = authenticationTemplate;
-  }
-
-  // Use the API client's fetch method directly - let it handle auth automatically
-  return await api.fetch(relayPath, {
-    method,
-    body,
-    headers,
-  });
-}

package/src/functions/request/info.ts

@@ -1,11 +0,0 @@
-import { request } from "./index";
-import { RelayRequestSchema } from "./schemas";
-
-export const requestInfo = {
-  name: "request",
-  inputSchema: RelayRequestSchema,
-  implementation: request,
-};
-
-// Legacy export for compatibility
-export const fetchInfo = requestInfo;

package/src/functions/runAction/index.ts

@@ -1,127 +0,0 @@
-import { getOrCreateApiClient, generateRequestId } from "../../api";
-import type { ActionExecutionResult } from "../../types/domain";
-import { getAction } from "../getAction";
-import { getApp } from "../getApp";
-import type { RunActionOptions } from "./schemas";
-
-/**
- * Execute an action
- *
- * This function can be used standalone without instantiating a full SDK,
- * which enables better tree-shaking in applications that only need this functionality.
- *
- * @param options - Action execution parameters and API configuration options
- * @returns Promise<ActionExecutionResult>
- */
-export async function runAction(
-  options: RunActionOptions,
-): Promise<ActionExecutionResult> {
-  const {
-    appKey,
-    actionType,
-    actionKey,
-    inputs,
-    authenticationId: providedAuthenticationId,
-  } = options;
-
-  const api = getOrCreateApiClient(options);
-
-  // Validate that the action exists
-  const actionData = await getAction({
-    ...options,
-    appKey: appKey,
-    actionKey: actionKey,
-    actionType: actionType,
-  });
-
-  // Validate action type matches
-  if (actionData.type !== actionType) {
-    throw new Error(
-      `Action type mismatch: expected ${actionType}, got ${actionData.type}`,
-    );
-  }
-
-  // Execute the action using the Actions API (supports all action types)
-  const startTime = Date.now();
-  const result = await executeAction({
-    api,
-    appSlug: appKey,
-    actionKey: actionKey,
-    actionType: actionData.type,
-    executionOptions: { inputs: inputs || {} },
-    authenticationId: providedAuthenticationId,
-    options,
-  });
-  const executionTime = Date.now() - startTime;
-
-  return {
-    success: true,
-    data: result,
-    metadata: {
-      executionTime,
-      requestId: generateRequestId(),
-    },
-  };
-}
-
-interface ExecuteActionOptions {
-  api: any;
-  appSlug: string;
-  actionKey: string;
-  actionType: string;
-  executionOptions: { inputs: Record<string, any> };
-  authenticationId?: number;
-  options: RunActionOptions;
-}
-
-async function executeAction(
-  actionOptions: ExecuteActionOptions,
-): Promise<any> {
-  const {
-    api,
-    appSlug,
-    actionKey,
-    actionType,
-    executionOptions,
-    authenticationId,
-    options,
-  } = actionOptions;
-
-  // Use the standalone getApp function
-  const appData = await getApp({
-    appKey: appSlug,
-    api,
-    token: options.token,
-    baseUrl: options.baseUrl,
-    debug: options.debug,
-    fetch: options.fetch,
-  });
-  const selectedApi = appData.current_implementation_id;
-
-  if (!selectedApi) {
-    throw new Error("No current_implementation_id found for app");
-  }
-
-  // Step 1: POST to /actions/v1/runs to start execution
-  const runRequest = {
-    data: {
-      authentication_id: authenticationId || 1,
-      selected_api: selectedApi,
-      action_key: actionKey,
-      action_type: actionType,
-      inputs: executionOptions.inputs || {},
-    },
-  };
-
-  const runData = await api.post("/api/actions/v1/runs", runRequest);
-  const runId = runData.data.id;
-
-  // Step 2: Poll GET /actions/v1/runs/{run_id} for results
-  return await api.poll(`/api/actions/v1/runs/${runId}`, {
-    successStatus: 200,
-    pendingStatus: 202,
-    resultExtractor: (result: any) => result.data,
-  });
-}
-
-// No registry info here - moved to info.ts for proper tree-shaking

package/src/functions/runAction/info.ts

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

package/src/functions/runAction/schemas.ts

@@ -1,34 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  ActionTypePropertySchema,
-  ActionKeyPropertySchema,
-  AuthenticationIdPropertySchema,
-  InputsPropertySchema,
-} from "../../types/properties";
-import type {
-  ActionExecutionResult,
-  FunctionOptions,
-} from "../../types/domain";
-
-// Pure Zod schema - no resolver metadata!
-export const RunActionSchema = z
-  .object({
-    appKey: AppKeyPropertySchema,
-    actionType: ActionTypePropertySchema,
-    actionKey: ActionKeyPropertySchema,
-    inputs: InputsPropertySchema.optional().describe(
-      "Input parameters for the action",
-    ),
-    authenticationId: AuthenticationIdPropertySchema.optional(),
-  })
-  .describe("Execute an action with the given inputs");
-
-// Type inferred from schema + function config
-export type RunActionOptions = z.infer<typeof RunActionSchema> &
-  FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface RunActionSdkFunction {
-  runAction: (options: RunActionOptions) => Promise<ActionExecutionResult>;
-}