@zapier/zapier-sdk 0.4.1 → 0.5.0

package/src/functions/generateTypes/schemas.ts

@@ -1,31 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  AuthenticationIdPropertySchema,
-  OutputPropertySchema,
-  DebugPropertySchema,
-} from "../../types/properties";
-import type { FunctionOptions } from "../../types/domain";
-
-// Pure Zod schema - no resolver metadata!
-export const GenerateTypesSchema = z
-  .object({
-    appKey: AppKeyPropertySchema.describe("App key to generate SDK code for"),
-    authenticationId: AuthenticationIdPropertySchema.optional(),
-    output: OutputPropertySchema.optional().describe(
-      "Output file path (defaults to generated/<appKey>.ts)",
-    ),
-    debug: DebugPropertySchema.describe(
-      "Enable debug logging during generation",
-    ),
-  })
-  .describe("Generate TypeScript SDK code for a specific app");
-
-// Type inferred from schema + function config
-export type GenerateTypesOptions = z.infer<typeof GenerateTypesSchema> &
-  FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface GenerateTypesSdkFunction {
-  generateTypes: (options: GenerateTypesOptions) => Promise<string>;
-}

package/src/functions/getAction/index.ts

@@ -1,33 +0,0 @@
-import type { Action } from "../../types/domain";
-import { listActions } from "../listActions";
-import type { GetActionOptions } from "./schemas";
-
-/**
- * Get a specific action by app, action key, and type
- *
- * 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 - App key, action key, type, and API configuration options
- * @returns Promise<Action>
- */
-export async function getAction(options: GetActionOptions): Promise<Action> {
-  const { appKey, actionKey, actionType } = options;
-
-  const actions = await listActions({
-    ...options,
-    appKey: appKey,
-  });
-
-  const action = actions.find(
-    (a) => a.key === actionKey && a.type === actionType,
-  );
-
-  if (!action) {
-    throw new Error(`Action not found: ${actionKey} with type ${actionType}`);
-  }
-
-  return action;
-}
-
-// No registry info here - moved to info.ts for proper tree-shaking

package/src/functions/getAction/info.ts

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

package/src/functions/getAction/schemas.ts

@@ -1,25 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  ActionTypePropertySchema,
-  ActionKeyPropertySchema,
-} from "../../types/properties";
-import type { Action, FunctionOptions } from "../../types/domain";
-
-// Pure Zod schema - no resolver metadata!
-export const GetActionSchema = z
-  .object({
-    appKey: AppKeyPropertySchema,
-    actionType: ActionTypePropertySchema,
-    actionKey: ActionKeyPropertySchema,
-  })
-  .describe("Get detailed information about a specific action");
-
-// Type inferred from schema + function config
-export type GetActionOptions = z.infer<typeof GetActionSchema> &
-  FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface GetActionSdkFunction {
-  getAction: (options: GetActionOptions) => Promise<Action>;
-}

package/src/functions/getApp/index.ts

@@ -1,41 +0,0 @@
-import { getOrCreateApiClient } from "../../api";
-import type { Integration } from "../../types/domain";
-import { AppNotFoundError } from "../../types/domain";
-import type { GetAppOptions } from "./schemas";
-
-/**
- * Get a specific app by key
- *
- * 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 - App key and API configuration options
- * @returns Promise<Integration>
- */
-export async function getApp(options: GetAppOptions): Promise<Integration> {
-  const api = getOrCreateApiClient(options);
-
-  const { appKey } = options;
-
-  const app = await api.get(`/api/v4/apps/${appKey}/`, {
-    customErrorHandler: (response) => {
-      if (response.status === 404) {
-        return new AppNotFoundError(appKey);
-      }
-      return undefined;
-    },
-  });
-
-  return {
-    key: app.slug,
-    name: app.name,
-    description: app.description,
-    version: "1.0.0",
-    category: app.category?.name,
-    actions: [],
-    triggers: [],
-    current_implementation_id: app.current_implementation_id,
-  };
-}
-
-// No registry info here - moved to info.ts for proper tree-shaking

package/src/functions/getApp/info.ts

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

package/src/functions/getApp/schemas.ts

@@ -1,20 +0,0 @@
-import { z } from "zod";
-import { AppKeyPropertySchema } from "../../types/properties";
-import type { Integration, FunctionOptions } from "../../types/domain";
-
-// Pure Zod schema - no resolver metadata!
-export const GetAppSchema = z
-  .object({
-    appKey: AppKeyPropertySchema.describe(
-      "App key or slug to fetch (e.g., google-sheets, slack, github)",
-    ),
-  })
-  .describe("Get detailed information about a specific app");
-
-// Type inferred from schema + function config
-export type GetAppOptions = z.infer<typeof GetAppSchema> & FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface GetAppSdkFunction {
-  getApp: (options: GetAppOptions) => Promise<Integration>;
-}

package/src/functions/getAuthentication/index.ts

@@ -1,50 +0,0 @@
-import { getOrCreateApiClient } from "../../api";
-import type { Authentication } from "../../types/domain";
-import type { GetAuthenticationOptions } from "./schemas";
-
-/**
- * Get a specific authentication by ID
- *
- * 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 - Authentication ID and API configuration options
- * @returns Promise<Authentication> - The authentication details
- * @throws Error if authentication not found or access denied
- */
-export async function getAuthentication(
-  options: GetAuthenticationOptions,
-): Promise<Authentication> {
-  const { authenticationId } = options;
-  const api = getOrCreateApiClient(options);
-
-  const data: Authentication = await api.get(
-    `/api/v4/authentications/${authenticationId}/`,
-    {
-      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 get authentication ${authenticationId}. (HTTP ${response.status})`,
-          );
-        }
-        if (response.status === 404) {
-          return new Error(
-            `Authentication ${authenticationId} not found. It may not exist or you may not have access to it. (HTTP ${response.status})`,
-          );
-        }
-        return undefined;
-      },
-    },
-  );
-
-  // Coerce title from label if title is missing (API cleanup)
-  return {
-    ...data,
-    title: data.title || (data as any).label || undefined,
-  };
-}

package/src/functions/getAuthentication/info.ts

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

package/src/functions/getAuthentication/schemas.ts

@@ -1,29 +0,0 @@
-import { z } from "zod";
-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 GetAuthenticationSchema = withOutputSchema(
-  z
-    .object({
-      authenticationId: z
-        .number()
-        .int()
-        .positive()
-        .describe("Authentication ID to retrieve"),
-    })
-    .describe("Get a specific authentication by ID"),
-  AuthItemSchema,
-);
-
-// Type inferred from schema + function config
-export type GetAuthenticationOptions = z.infer<typeof GetAuthenticationSchema> &
-  FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface GetAuthenticationSdkFunction {
-  getAuthentication: (
-    options: GetAuthenticationOptions,
-  ) => Promise<Authentication>;
-}

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