@zapier/zapier-sdk 0.4.1 → 0.5.0

package/src/functions/bundleCode/index.ts

@@ -1,78 +0,0 @@
-import type { BundleCodeOptions } from "./schemas";
-
-/**
- * Bundle TypeScript code into executable JavaScript
- *
- * 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 - Bundling configuration options
- * @returns Promise<string> - Bundled JavaScript code
- */
-export async function bundleCode(options: BundleCodeOptions): Promise<string> {
-  const {
-    input,
-    output,
-    target = "es2020",
-    cjs = false,
-    minify = false,
-    string: returnString = false,
-  } = options;
-
-  // Dynamically import esbuild
-  const { buildSync } = await import("esbuild");
-  const fs = await import("fs");
-  const path = await import("path");
-
-  // Resolve input path
-  const resolvedInput = path.resolve(process.cwd(), input);
-
-  try {
-    // Bundle with esbuild
-    const result = buildSync({
-      entryPoints: [resolvedInput],
-      bundle: true,
-      platform: "node",
-      target: target,
-      format: cjs ? "cjs" : "esm",
-      minify: minify,
-      write: false,
-      external: [], // Bundle everything
-      banner: {
-        js: "#!/usr/bin/env node",
-      },
-    });
-
-    if (result.errors.length > 0) {
-      throw new Error(
-        `Bundle failed: ${result.errors.map((e) => e.text).join(", ")}`,
-      );
-    }
-
-    const bundledCode = result.outputFiles?.[0]?.text;
-    if (!bundledCode) {
-      throw new Error("No output generated");
-    }
-
-    let finalOutput = bundledCode;
-
-    if (returnString) {
-      // Output as quoted string for node -e using JSON.stringify
-      finalOutput = JSON.stringify(bundledCode);
-    }
-
-    // Write to file if output path specified
-    if (output) {
-      fs.mkdirSync(path.dirname(output), { recursive: true });
-      fs.writeFileSync(output, finalOutput, "utf8");
-    }
-
-    return finalOutput;
-  } catch (error) {
-    throw new Error(
-      `Bundle failed: ${
-        error instanceof Error ? error.message : "Unknown error"
-      }`,
-    );
-  }
-}

package/src/functions/bundleCode/info.ts

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

package/src/functions/bundleCode/schemas.ts

@@ -1,30 +0,0 @@
-import { z } from "zod";
-import { OutputPropertySchema } from "../../types/properties";
-
-// Pure Zod schema - no resolver metadata!
-export const BundleCodeSchema = z
-  .object({
-    input: z.string().min(1).describe("Input TypeScript file path to bundle"),
-    output: OutputPropertySchema.optional().describe(
-      "Output file path (defaults to input with .js extension)",
-    ),
-    string: z
-      .boolean()
-      .default(false)
-      .describe("Return bundled code as string instead of writing to file"),
-    minify: z.boolean().default(false).describe("Minify the bundled output"),
-    target: z.string().default("es2017").describe("ECMAScript target version"),
-    cjs: z
-      .boolean()
-      .default(false)
-      .describe("Output CommonJS format instead of ESM"),
-  })
-  .describe("Bundle TypeScript code into executable JavaScript");
-
-// Type inferred from schema (no additional function config needed for bundleCode)
-export type BundleCodeOptions = z.infer<typeof BundleCodeSchema>;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface BundleCodeSdkFunction {
-  bundleCode: (options: BundleCodeOptions) => Promise<string>;
-}

package/src/functions/findFirstAuthentication/index.ts

@@ -1,24 +0,0 @@
-import type { Authentication } from "../../types/domain";
-import { listAuthentications } from "../listAuthentications";
-import type { FindFirstAuthenticationOptions } from "./schemas";
-
-/**
- * Find the first authentication matching the given criteria
- *
- * 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<Authentication | null> - First matching authentication or null if not found
- */
-export async function findFirstAuthentication(
-  options: Partial<FindFirstAuthenticationOptions> = {},
-): Promise<Authentication | null> {
-  // Use listAuthentications with limit 1 to get the first result
-  const auths = await listAuthentications({
-    ...options,
-    limit: 1,
-  });
-
-  return auths.length > 0 ? auths[0] : null;
-}

package/src/functions/findFirstAuthentication/info.ts

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

package/src/functions/findFirstAuthentication/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 FindFirstAuthenticationSchema = 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("Find the first authentication matching the criteria"),
-  AuthItemSchema,
-);
-
-// Type inferred from schema + function config
-export type FindFirstAuthenticationOptions = z.infer<
-  typeof FindFirstAuthenticationSchema
-> &
-  FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface FindFirstAuthenticationSdkFunction {
-  findFirstAuthentication: (
-    options?: Partial<FindFirstAuthenticationOptions>,
-  ) => Promise<Authentication | null>;
-}

package/src/functions/findUniqueAuthentication/index.ts

@@ -1,35 +0,0 @@
-import type { Authentication } from "../../types/domain";
-import { listAuthentications } from "../listAuthentications";
-import type { FindUniqueAuthenticationOptions } from "./schemas";
-
-/**
- * Find a unique authentication matching the given criteria
- *
- * 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<Authentication> - The unique matching authentication
- * @throws Error if no authentication found or multiple authentications found
- */
-export async function findUniqueAuthentication(
-  options: Partial<FindUniqueAuthenticationOptions> = {},
-): Promise<Authentication> {
-  // Use listAuthentications with a reasonable limit to check for uniqueness
-  const auths = await listAuthentications({
-    ...options,
-    limit: 2, // Get up to 2 to check for uniqueness
-  });
-
-  if (auths.length === 0) {
-    throw new Error("No authentication found matching the specified criteria");
-  }
-
-  if (auths.length > 1) {
-    throw new Error(
-      "Multiple authentications found matching the specified criteria. Expected exactly one.",
-    );
-  }
-
-  return auths[0];
-}

package/src/functions/findUniqueAuthentication/info.ts

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

package/src/functions/findUniqueAuthentication/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 FindUniqueAuthenticationSchema = 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("Find a unique authentication matching the criteria"),
-  AuthItemSchema,
-);
-
-// Type inferred from schema + function config
-export type FindUniqueAuthenticationOptions = z.infer<
-  typeof FindUniqueAuthenticationSchema
-> &
-  FunctionOptions;
-
-// SDK function interface - ready to be mixed into main SDK interface
-export interface FindUniqueAuthenticationSdkFunction {
-  findUniqueAuthentication: (
-    options?: Partial<FindUniqueAuthenticationOptions>,
-  ) => Promise<Authentication>;
-}

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