@zapier/zapier-sdk 0.4.0 → 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/fetch/index.ts

@@ -1,180 +0,0 @@
-import { getOrCreateApiClient } from "../../api";
-import type { FunctionOptions } from "../../types/domain";
-
-export interface RelayFetchOptions {
-  /** HTTP method */
-  method?: string;
-  /** Request body as a string */
-  body?: string;
-  /** 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;
-}
-
-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 fetch functionality
- */
-export async function fetch(
-  options: {
-    url: string;
-    method?: string;
-    body?: string;
-    headers?: Record<string, string>;
-    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: RelayFetchOptions = {},
-  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;
-  }
-
-  // For Relay requests, we need to disable the default authorization and add our own
-  const requestOptions = {
-    headers,
-    authRequired: false, // Disable automatic Authorization header
-    customErrorHandler: (response: Response) => {
-      if (!response.ok) {
-        return new Error(
-          `Relay request failed: ${response.status} ${response.statusText}`,
-        );
-      }
-      return undefined;
-    },
-  };
-
-  // Add X-Relay-Authorization header manually
-  let token = config.token;
-  if (!token && config.getToken) {
-    token = await config.getToken();
-  }
-  if (!token) {
-    const { getTokenFromEnvOrConfig } = await import("../../auth");
-    token = await getTokenFromEnvOrConfig({
-      onEvent: config.onEvent,
-      fetch: config.fetch,
-    });
-  }
-  if (token) {
-    const { getAuthorizationHeader } = await import("../../api/auth");
-    headers["X-Relay-Authorization"] = getAuthorizationHeader(token);
-  }
-
-  // Use the API client's fetch method directly
-  return await api.fetch(relayPath, {
-    method,
-    body,
-    headers: requestOptions.headers,
-    authRequired: requestOptions.authRequired,
-    customErrorHandler: requestOptions.customErrorHandler,
-  });
-}

package/src/functions/fetch/info.ts

@@ -1,8 +0,0 @@
-import { fetch } from "./index";
-import { RelayFetchSchema } from "./schemas";
-
-export const fetchInfo = {
-  name: "fetch",
-  inputSchema: RelayFetchSchema,
-  implementation: fetch,
-};

package/src/functions/fetch/schemas.ts

@@ -1,46 +0,0 @@
-import { z } from "zod";
-import type { FunctionOptions } from "../../types/domain";
-
-// Pure Zod schema for the fetch function
-export const RelayFetchSchema = z
-  .object({
-    url: z
-      .string()
-      .url()
-      .describe("The URL to fetch (will be proxied through Relay)"),
-    method: z
-      .enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
-      .optional()
-      .describe("HTTP method"),
-    body: z.string().optional().describe("Request body as a string"),
-    authenticationId: z
-      .number()
-      .int()
-      .optional()
-      .describe("Zapier authentication ID to use for the request"),
-    callbackUrl: z
-      .string()
-      .url()
-      .optional()
-      .describe("URL to send async response to (makes request async)"),
-    authenticationTemplate: z
-      .string()
-      .optional()
-      .describe(
-        "Optional JSON string authentication template to bypass Notary lookup",
-      ),
-    headers: z.record(z.string()).optional().describe("Request headers"),
-  })
-  .describe("Make authenticated HTTP requests through Zapier's Relay service");
-
-// Type inferred from schema + function config
-export type RelayFetchOptions = z.infer<typeof RelayFetchSchema> &
-  FunctionOptions & {
-    /** Base URL for Relay service */
-    relayBaseUrl?: string;
-  };
-
-// SDK function interface
-export interface RelayFetchSdkFunction {
-  fetch: (options: RelayFetchOptions) => Promise<Response>;
-}

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