@zapier/zapier-sdk 0.4.0 → 0.5.0

package/src/functions/listActions/index.ts

@@ -1,149 +0,0 @@
-import { getOrCreateApiClient } from "../../api";
-import type { Action } from "../../types/domain";
-import { getApp } from "../getApp";
-import type { ListActionsOptions } from "./schemas";
-
-/**
- * List available actions 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 and API configuration options
- * @returns Promise<Action[]> with pagination metadata
- */
-export async function listActions(
-  options: Partial<ListActionsOptions> = {},
-): Promise<Action[]> {
-  const api = getOrCreateApiClient(options);
-
-  // If filtering by appKey, use optimized approach with selected_apis parameter
-  if (options.appKey) {
-    try {
-      // Use the standalone getApp function
-      const appData = await getApp({
-        appKey: options.appKey,
-        api,
-        token: options.token,
-        baseUrl: options.baseUrl,
-        debug: options.debug,
-        fetch: options.fetch,
-      });
-
-      // Extract implementation name from current_implementation_id (e.g., "SlackCLIAPI@1.20.0" -> "SlackCLIAPI")
-      const implementationId = appData.current_implementation_id?.split("@")[0];
-      if (!implementationId) {
-        throw new Error("No current_implementation_id found for app");
-      }
-
-      const searchParams = {
-        global: "true",
-        public_only: "true",
-        selected_apis: implementationId,
-      };
-
-      const data = await api.get("/api/v4/implementations/", {
-        searchParams,
-      });
-      const actions: Action[] = [];
-
-      // Transform implementations to actions
-      for (const implementation of data.results || []) {
-        if (implementation.actions) {
-          for (const action of implementation.actions) {
-            const transformedAction: Action = {
-              key: action.key,
-              name: action.name || action.label,
-              description: action.description || "",
-              appKey: implementation.slug || "",
-              type: action.type || action.type_of || "read",
-              inputFields: [], // Would need additional API call for detailed fields
-              outputFields: [],
-            };
-
-            // Apply type filter if provided
-            if (options?.type && transformedAction.type !== options.type) {
-              continue;
-            }
-
-            actions.push(transformedAction);
-          }
-        }
-      }
-
-      // Add pagination metadata for app-specific queries
-      if (actions.length > 0) {
-        (actions as any).__pagination = {
-          count: data.count,
-          hasNext: !!data.next,
-          hasPrevious: !!data.previous,
-          nextUrl: data.next,
-          previousUrl: data.previous,
-        };
-      }
-
-      return actions;
-    } catch (error) {
-      // If it's an AppNotFoundError, don't try fallback - just re-throw
-      if (error instanceof Error && error.name === "AppNotFoundError") {
-        throw error;
-      }
-      // Fallback to original approach if optimized approach fails
-      console.warn(
-        "Optimized app lookup failed, falling back to full scan:",
-        error,
-      );
-    }
-  }
-
-  // Original approach for general queries or when optimization fails
-  const searchParams = {
-    global: "true",
-    public_only: "true",
-  };
-
-  const data = await api.get("/api/v4/implementations/", { searchParams });
-  const actions: Action[] = [];
-
-  // Transform implementations to actions
-  for (const implementation of data.results || []) {
-    if (implementation.actions) {
-      for (const action of implementation.actions) {
-        const transformedAction: Action = {
-          key: action.key,
-          name: action.name || action.label,
-          description: action.description || "",
-          appKey: implementation.slug || "",
-          type: action.type || action.type_of || "read",
-          inputFields: [], // Would need additional API call for detailed fields
-          outputFields: [],
-        };
-
-        // Apply filters
-        if (options?.appKey && transformedAction.appKey !== options.appKey) {
-          continue;
-        }
-        if (options?.type && transformedAction.type !== options.type) {
-          continue;
-        }
-
-        actions.push(transformedAction);
-      }
-    }
-  }
-
-  // Add pagination metadata for general queries
-  if (actions.length > 0) {
-    (actions as any).__pagination = {
-      count: data.count,
-      hasNext: !!data.next,
-      hasPrevious: !!data.previous,
-      nextUrl: data.next,
-      previousUrl: data.previous,
-    };
-  }
-
-  return actions;
-}
-
-// No registry info here - moved to info.ts for proper tree-shaking

package/src/functions/listActions/info.ts

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

package/src/functions/listActions/schemas.ts

@@ -1,30 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  ActionTypePropertySchema,
-} from "../../types/properties";
-import { withOutputSchema } from "../../schema-utils";
-import { ActionItemSchema } from "../../schemas/Action";
-import type { Action, FunctionOptions } from "../../types/domain";
-
-// Pure Zod schema - no resolver metadata!
-export const ListActionsSchema = withOutputSchema(
-  z
-    .object({
-      appKey: AppKeyPropertySchema.optional(),
-      type: ActionTypePropertySchema.optional().describe(
-        "Filter actions by type",
-      ),
-    })
-    .describe("List all actions for a specific app"),
-  ActionItemSchema,
-);
-
-// Type inferred from schema + function config
-export type ListActionsOptions = z.infer<typeof ListActionsSchema> &
-  FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface ListActionsSdkFunction {
-  listActions: (options?: Partial<ListActionsOptions>) => Promise<Action[]>;
-}

package/src/functions/listApps/index.ts

@@ -1,60 +0,0 @@
-import { getOrCreateApiClient } from "../../api";
-import type { Integration } from "../../types/domain";
-import type { ListAppsOptions } from "./schemas";
-
-/**
- * List available apps 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<Integration[]> with pagination metadata
- */
-export async function listApps(
-  options: ListAppsOptions = {},
-): Promise<Integration[]> {
-  const api = getOrCreateApiClient(options);
-
-  // Build search parameters
-  const searchParams: Record<string, string> = {};
-  if (options.category) {
-    searchParams.category = options.category;
-  }
-  if (options.limit) {
-    searchParams.limit = options.limit.toString();
-  }
-  if (options.offset) {
-    searchParams.offset = options.offset.toString();
-  }
-
-  const data = await api.get("/api/v4/apps/", { searchParams });
-
-  // Transform API response to our Integration interface
-  const apps =
-    data.results?.map(
-      (app: any): Integration => ({
-        key: app.slug,
-        name: app.name,
-        description: app.description,
-        version: "1.0.0", // API doesn't provide version
-        category: app.category?.name,
-        actions: [], // Will be populated separately
-        triggers: [],
-        current_implementation_id: app.current_implementation_id,
-      }),
-    ) || [];
-
-  // Add pagination metadata to the response
-  if (apps.length > 0) {
-    (apps as any).__pagination = {
-      count: data.count,
-      hasNext: !!data.next,
-      hasPrevious: !!data.previous,
-      nextUrl: data.next,
-      previousUrl: data.previous,
-    };
-  }
-
-  return apps;
-}

package/src/functions/listApps/info.ts

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

package/src/functions/listApps/schemas.ts

@@ -1,32 +0,0 @@
-import { z } from "zod";
-import {
-  LimitPropertySchema,
-  OffsetPropertySchema,
-} from "../../types/properties";
-import { withOutputSchema } from "../../schema-utils";
-import { AppItemSchema } from "../../schemas/App";
-import type { Integration, FunctionOptions } from "../../types/domain";
-
-// Pure Zod schema - no resolver metadata!
-export const ListAppsSchema = withOutputSchema(
-  z
-    .object({
-      category: z.string().optional().describe("Filter apps by category"),
-      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 all available apps with optional filtering"),
-  AppItemSchema,
-);
-
-// Type inferred from schema + function config
-export type ListAppsOptions = z.infer<typeof ListAppsSchema> & FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface ListAppsSdkFunction {
-  listApps: (options?: Partial<ListAppsOptions>) => Promise<Integration[]>;
-}

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[]>;
-}