@zapier/zapier-sdk 0.4.0 → 0.5.0

package/src/functions/generateTypes/index.ts

@@ -1,363 +0,0 @@
-import type { Action, ActionField } from "../../types/domain";
-import { listActions } from "../listActions";
-import { listFields } from "../listFields";
-import type { GenerateTypesOptions } from "./schemas";
-
-interface ActionWithActionFields extends Omit<Action, "inputFields"> {
-  inputFields: ActionField[];
-}
-
-/**
- * Generate the fetch method signature for app proxies
- */
-function generateFetchMethodSignature(): string {
-  return `  /** Make authenticated HTTP requests through Zapier's Relay service */
-  fetch: (options: Omit<z.infer<typeof RelayFetchSchema>, 'authenticationId'>) => Promise<Response>`;
-}
-
-/**
- * Generate TypeScript types for a specific app
- *
- * 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, authentication ID, output path, and API configuration options
- * @returns Promise<string> - Generated TypeScript code
- */
-export async function generateTypes(
-  options: GenerateTypesOptions,
-): Promise<string> {
-  const {
-    appKey,
-    authenticationId,
-    output = `./types/${appKey}.d.ts`,
-  } = options;
-
-  // Parse app identifier (support app@version format)
-  const { app, version } = parseAppIdentifier(appKey);
-
-  // Fetch all actions for the app
-  const actions = await listActions({
-    ...options,
-    appKey: app,
-  });
-
-  if (actions.length === 0) {
-    const typeDefinitions = generateEmptyTypesFile(app, version);
-
-    if (output) {
-      const fs = await import("fs");
-      const path = await import("path");
-      fs.mkdirSync(path.dirname(output), { recursive: true });
-      fs.writeFileSync(output, typeDefinitions, "utf8");
-    }
-
-    return typeDefinitions;
-  }
-
-  // Fetch input fields for each action
-  const actionsWithFields: ActionWithActionFields[] = [];
-
-  if (authenticationId) {
-    for (const action of actions) {
-      try {
-        const fields = await listFields({
-          ...options,
-          appKey: action.appKey,
-          actionKey: action.key,
-          actionType: action.type,
-          authenticationId: authenticationId,
-        });
-        actionsWithFields.push({ ...action, inputFields: fields });
-      } catch {
-        // If we can't get fields for an action, include it without fields
-        actionsWithFields.push({ ...action, inputFields: [] });
-      }
-    }
-  } else {
-    // Convert actions to have empty input fields (will generate generic types)
-    actions.forEach((action) => {
-      actionsWithFields.push({ ...action, inputFields: [] });
-    });
-  }
-
-  // Generate TypeScript types
-  const typeDefinitions = generateTypeDefinitions(
-    app,
-    actionsWithFields,
-    version,
-  );
-
-  // Write to file if output path specified
-  if (output) {
-    const fs = await import("fs");
-    const path = await import("path");
-    fs.mkdirSync(path.dirname(output), { recursive: true });
-    fs.writeFileSync(output, typeDefinitions, "utf8");
-  }
-
-  return typeDefinitions;
-}
-
-function parseAppIdentifier(identifier: string): {
-  app: string;
-  version?: string;
-} {
-  const parts = identifier.split("@");
-  return {
-    app: parts[0],
-    version: parts[1],
-  };
-}
-
-function generateTypeDefinitions(
-  appKey: string,
-  actions: ActionWithActionFields[],
-  version?: string,
-): string {
-  // Handle empty actions
-  if (actions.length === 0) {
-    return generateEmptyTypesFile(appKey, version);
-  }
-
-  // Group actions by type
-  const actionsByType = actions.reduce(
-    (acc, action) => {
-      if (!acc[action.type]) {
-        acc[action.type] = [];
-      }
-      acc[action.type].push(action);
-      return acc;
-    },
-    {} as Record<string, ActionWithActionFields[]>,
-  );
-
-  const appName = capitalize(appKey);
-  const versionComment = version
-    ? ` * Generated for ${appKey}@${version}`
-    : ` * Generated for ${appKey}`;
-
-  let output = `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${new Date().toISOString()}
- * 
- * Usage:
- *   import type { ${appName}Sdk } from './path/to/this/file'
- *   const sdk = createZapierSdk() as unknown as ${appName}Sdk
- *   
- *   // Direct usage (per-call auth):
- *   await sdk.apps.${appKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
- *   
- *   // Factory usage (pinned auth):
- *   const my${appName} = sdk.apps.${appKey}({ authenticationId: 123 })
- *   await my${appName}.search.user_by_email({ inputs: { email } })
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-`;
-
-  // Generate input types for each action
-  actions.forEach((action) => {
-    if (action.inputFields.length > 0) {
-      const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(
-        sanitizeActionName(action.key),
-      )}Inputs`;
-
-      output += `interface ${inputTypeName} {\n`;
-
-      action.inputFields.forEach((field) => {
-        const isOptional = !field.required;
-        const fieldType = mapFieldTypeToTypeScript(field);
-        const description = field.helpText
-          ? `  /** ${escapeComment(field.helpText)} */\n`
-          : "";
-
-        output += `${description}  ${sanitizeFieldName(field.key)}${
-          isOptional ? "?" : ""
-        }: ${fieldType}\n`;
-      });
-
-      output += `}\n\n`;
-    }
-  });
-
-  // Generate action type interfaces for each action type
-  Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-
-    output += `interface ${typeName} {\n`;
-
-    typeActions.forEach((action: ActionWithActionFields) => {
-      const actionName = sanitizeActionName(action.key);
-      const description = action.description
-        ? `  /** ${escapeComment(action.description)} */\n`
-        : "";
-
-      // Generate type-safe action method signature
-      if (action.inputFields.length > 0) {
-        const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(
-          sanitizeActionName(action.key),
-        )}Inputs`;
-        output += `${description}  ${actionName}: (options: { inputs: ${inputTypeName} } & Omit<ActionExecutionOptions, 'inputs'>) => Promise<ActionExecutionResult>\n`;
-      } else {
-        // No specific input fields available - use generic Record<string, any> for inputs
-        output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>\n`;
-      }
-    });
-
-    output += `}\n\n`;
-  });
-
-  // Generate the main app SDK interface with factory pattern support
-
-  // Generate the app proxy interface (actions grouped by type)
-  output += `interface ${appName}AppProxy {\n`;
-  Object.keys(actionsByType).forEach((actionType) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-    output += `  ${actionType}: ${typeName}\n`;
-  });
-  // Always include fetch method for authenticated HTTP requests
-  output += generateFetchMethodSignature() + "\n";
-  output += `}\n\n`;
-
-  // Generate the factory function interface
-  output += `interface ${appName}AppFactory {\n`;
-  output += `  (options: { authenticationId: number }): ${appName}AppProxy\n`;
-  output += `}\n\n`;
-
-  // Combine factory and direct access
-  output += `type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy\n\n`;
-
-  // Generate the main SDK interface
-  output += `export interface ${appName}Sdk {\n`;
-  output += `  apps: {\n`;
-  output += `    ${appKey}: ${appName}AppWithFactory\n`;
-  output += `  }\n`;
-  output += `}\n`;
-
-  return output;
-}
-
-function generateEmptyTypesFile(appKey: string, version?: string): string {
-  const appName = capitalize(appKey);
-  const versionComment = version
-    ? ` * Generated for ${appKey}@${version}`
-    : ` * Generated for ${appKey}`;
-
-  return `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${new Date().toISOString()}
- * 
- * No actions found for this app.
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-interface ${appName}AppProxy {
-  // No actions available
-${generateFetchMethodSignature()}
-}
-
-interface ${appName}AppFactory {
-  (options: { authenticationId: number }): ${appName}AppProxy
-}
-
-type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
-
-export interface ${appName}Sdk {
-  apps: {
-    ${appKey}: ${appName}AppWithFactory
-  }
-}
-`;
-}
-
-function capitalize(str: string): string {
-  return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-}
-
-function sanitizeActionName(actionKey: string): string {
-  // Ensure the action name is a valid TypeScript identifier
-  let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-
-  // If it starts with a number, prepend an underscore
-  if (/^[0-9]/.test(sanitized)) {
-    sanitized = "_" + sanitized;
-  }
-
-  return sanitized;
-}
-
-function sanitizeFieldName(fieldKey: string): string {
-  // Ensure the field name is a valid TypeScript identifier
-  let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-
-  // If it starts with a number, prepend an underscore
-  if (/^[0-9]/.test(sanitized)) {
-    sanitized = "_" + sanitized;
-  }
-
-  return sanitized;
-}
-
-function escapeComment(comment: string): string {
-  // Escape comment text to prevent breaking the JSDoc comment
-  return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
-}
-
-function mapFieldTypeToTypeScript(field: ActionField): string {
-  // Handle choices (enum-like fields)
-  if (field.choices && field.choices.length > 0) {
-    const choiceValues = field.choices
-      .filter(
-        (choice) =>
-          choice.value !== undefined &&
-          choice.value !== null &&
-          choice.value !== "",
-      )
-      .map((choice) =>
-        typeof choice.value === "string" ? `"${choice.value}"` : choice.value,
-      );
-
-    if (choiceValues.length > 0) {
-      return choiceValues.join(" | ");
-    }
-    // If all choices were filtered out, fall through to default type handling
-  }
-
-  // Map Zapier field types to TypeScript types
-  switch (field.type?.toLowerCase()) {
-    case "string":
-    case "text":
-    case "email":
-    case "url":
-    case "password":
-      return "string";
-    case "integer":
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "datetime":
-    case "date":
-      return "string"; // ISO date strings
-    case "file":
-      return "string"; // File URL or content
-    case "array":
-      return "any[]";
-    case "object":
-      return "Record<string, any>";
-    default:
-      // Default to string for unknown types, with union for common cases
-      return "string | number | boolean";
-  }
-}

package/src/functions/generateTypes/info.ts

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

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