@zapier/zapier-sdk 0.4.0 → 0.5.0

package/src/api/types.ts

@@ -4,8 +4,37 @@
  * This module contains all type definitions related to the Zapier API client,
  * including configuration options, client interfaces, request/response types,
  * and API response models.
+ *
+ * API response model types are inferred from Zod schemas defined in api/schemas.ts
+ * to ensure a single source of truth and eliminate duplication.
  */
 
+import { z } from "zod";
+import {
+  NeedChoicesSchema,
+  NeedSchema,
+  ActionLinksSchema,
+  ActionPermissionsSchema,
+  ActionSchema,
+  ChoiceSchema,
+  FieldSchema,
+  ActionExecutionResultSchema,
+  ActionFieldChoiceSchema,
+  ActionFieldSchema,
+  AuthenticationSchema,
+  AuthenticationsResponseSchema,
+  UserProfileSchema,
+  AppSchema,
+  NeedsRequestSchema,
+  NeedsResponseSchema,
+  ImplementationSchema,
+  ImplementationsResponseSchema,
+  ImplementationMetaSchema,
+  ImplementationsMetaResponseSchema,
+  ServiceSchema,
+  ServicesResponseSchema,
+} from "./schemas";
+
 // ============================================================================
 // API Client Infrastructure Types
 // ============================================================================
@@ -26,11 +55,10 @@ export interface ApiClient {
   delete: (path: string, options?: RequestOptions) => Promise<any>;
   poll: (path: string, options?: PollOptions) => Promise<any>;
   fetch: (
-    input: string | URL,
+    path: string,
     init?: RequestInit & {
       searchParams?: Record<string, string>;
       authRequired?: boolean;
-      customErrorHandler?: (response: Response) => Error | undefined;
     },
   ) => Promise<Response>;
 }
@@ -39,7 +67,11 @@ export interface RequestOptions {
   headers?: Record<string, string>;
   searchParams?: Record<string, string>;
   authRequired?: boolean;
-  customErrorHandler?: (response: Response) => Error | undefined;
+  customErrorHandler?: (errorInfo: {
+    status: number;
+    statusText: string;
+    data: any;
+  }) => Error | undefined;
 }
 
 export interface PollOptions extends RequestOptions {
@@ -56,140 +88,43 @@ export interface DebugLogger {
 }
 
 // ============================================================================
-// API Response Models
+// API Response Models (inferred from Zod schemas)
 // ============================================================================
 
-export interface Integration {
-  key: string;
-  name: string;
-  description: string;
-  version: string;
-  category?: string;
-  actions: Action[];
-  triggers: Trigger[];
-  current_implementation_id?: string;
-}
-
-export interface Action {
-  key: string;
-  name: string;
-  description: string;
-  appKey: string;
-  type:
-    | "read"
-    | "read_bulk"
-    | "write"
-    | "run"
-    | "search"
-    | "search_or_write"
-    | "search_and_write"
-    | "filter";
-  inputFields: Field[];
-  outputFields: Field[];
-}
-
-export interface Trigger {
-  key: string;
-  name: string;
-  description: string;
-  appKey: string;
-  type: "instant" | "polling" | "webhook";
-  outputFields: Field[];
-}
-
-export interface Field {
-  key: string;
-  label: string;
-  type:
-    | "string"
-    | "number"
-    | "boolean"
-    | "datetime"
-    | "file"
-    | "object"
-    | "array";
-  required: boolean;
-  description?: string;
-  choices?: Choice[];
-}
-
-export interface Choice {
-  value: string | number;
-  label: string;
-}
-
-export interface ActionExecutionResult {
-  success: boolean;
-  data?: any;
-  error?: string;
-  metadata?: {
-    executionTime?: number;
-    requestId?: string;
-  };
-}
-
-export interface ActionField {
-  key: string;
-  label?: string;
-  required: boolean;
-  type?: string;
-  helpText?: string;
-  helpTextHtml?: string;
-  choices?: ActionFieldChoice[];
-  default?: string;
-  placeholder?: string;
-  computed?: boolean;
-  customField?: boolean;
-  dependsOn?: string[];
-  format?: string;
-  inputFormat?: string[];
-}
-
-export interface ActionFieldChoice {
-  value: string | number;
-  label: string;
-}
-
-export interface NeedsRequest {
-  selected_api: string;
-  action: string;
-  type_of: string;
-  authentication_id?: number;
-  params?: Record<string, any>;
-}
-
-export interface NeedsResponse {
-  success: boolean;
-  needs?: ActionField[];
-  errors?: string[];
-}
-
-export interface Authentication {
-  id: number;
-  date: string;
-  lastchanged?: string;
-  account_id: number;
-  customuser_id?: number;
-  selected_api: string;
-  destination_selected_api?: string | null;
-  is_invite_only: boolean;
-  is_private: boolean;
-  shared_with_all: boolean;
-  is_stale?: string;
-  is_shared?: string;
-  marked_stale_at?: string | null;
-  label?: string | null;
-  identifier?: string | null;
-  title?: string | null;
-  url?: string;
-  groups?: string;
-  members?: string;
-  permissions?: Record<string, boolean>;
-}
-
-export interface AuthenticationsResponse {
-  count: number;
-  next?: string | null;
-  previous?: string | null;
-  results: Authentication[];
-}
+// Basic building blocks
+export type NeedChoices = z.infer<typeof NeedChoicesSchema>;
+export type Need = z.infer<typeof NeedSchema>;
+export type ActionLinks = z.infer<typeof ActionLinksSchema>;
+export type ActionPermissions = z.infer<typeof ActionPermissionsSchema>;
+export type Action = z.infer<typeof ActionSchema>;
+export type Choice = z.infer<typeof ChoiceSchema>;
+export type Field = z.infer<typeof FieldSchema>;
+export type ActionExecutionResult = z.infer<typeof ActionExecutionResultSchema>;
+export type ActionFieldChoice = z.infer<typeof ActionFieldChoiceSchema>;
+export type ActionField = z.infer<typeof ActionFieldSchema>;
+
+// Main API entities
+export type Authentication = z.infer<typeof AuthenticationSchema>;
+export type AuthenticationsResponse = z.infer<
+  typeof AuthenticationsResponseSchema
+>;
+export type UserProfile = z.infer<typeof UserProfileSchema>;
+export type App = z.infer<typeof AppSchema>;
+export type Service = z.infer<typeof ServiceSchema>;
+export type ServicesResponse = z.infer<typeof ServicesResponseSchema>;
+
+// Request/Response types
+export type NeedsRequest = z.infer<typeof NeedsRequestSchema>;
+export type NeedsResponse = z.infer<typeof NeedsResponseSchema>;
+
+// Implementation types
+export type Implementation = z.infer<typeof ImplementationSchema>;
+export type ImplementationsResponse = z.infer<
+  typeof ImplementationsResponseSchema
+>;
+
+// Implementation Meta types (lightweight)
+export type ImplementationMeta = z.infer<typeof ImplementationMetaSchema>;
+export type ImplementationsMetaResponse = z.infer<
+  typeof ImplementationsMetaResponseSchema
+>;

package/src/constants.ts

@@ -0,0 +1,10 @@
+/**
+ * SDK Constants
+ *
+ * This module contains shared constants used throughout the SDK.
+ */
+
+/**
+ * Maximum number of items that can be requested per page across all paginated functions
+ */
+export const MAX_PAGE_LIMIT = 10000;

package/src/index.ts

@@ -1,10 +1,31 @@
 // Export everything from types and plugins
 export * from "./types/domain";
+export * from "./types/functions";
 export * from "./types/properties";
+export * from "./types/errors";
 export * from "./plugins/apps";
+export * from "./plugins/fetch";
+
+// Export API types directly (no longer re-exported from domain)
+export type {
+  Action,
+  App,
+  Need,
+  Field,
+  Choice,
+  ActionExecutionResult,
+  ActionField,
+  ActionFieldChoice,
+  NeedsRequest,
+  NeedsResponse,
+  Authentication,
+  AuthenticationsResponse,
+  UserProfile,
+} from "./api/types";
 
 // Export schema utilities for CLI
-export { isPositional } from "./schema-utils";
+export { isPositional } from "./utils/schema-utils";
+export { hasResolver } from "./resolvers";
 
 // Export auth utilities for CLI use
 export * from "./auth";
@@ -14,24 +35,28 @@ export * from "./resolvers";
 
 // Note: SdkSchemas is now available via SDK.__registry
 
-// Export individual functions for tree-shaking
-export { listAuthentications } from "./functions/listAuthentications";
-export { getAuthentication } from "./functions/getAuthentication";
-export { findFirstAuthentication } from "./functions/findFirstAuthentication";
-export { findUniqueAuthentication } from "./functions/findUniqueAuthentication";
-export { listApps } from "./functions/listApps";
-export { getApp } from "./functions/getApp";
-export { listActions } from "./functions/listActions";
-export { getAction } from "./functions/getAction";
-export { runAction } from "./functions/runAction";
-export { listFields } from "./functions/listFields";
-export { generateTypes } from "./functions/generateTypes";
-export { bundleCode } from "./functions/bundleCode";
-export { fetch, relayFetch } from "./functions/fetch";
-export { RelayFetchSchema } from "./functions/fetch/schemas";
-
-// Export the main combined SDK
-export { createZapierSdk, ZapierSdkOptions } from "./sdk";
+// All functions now available through the plugin system via createZapierSdk()
+// Export plugin schemas for external use
+export {
+  RelayRequestSchema,
+  RelayFetchSchema,
+} from "./plugins/request/schemas";
+
+// Export the main combined SDK and new flexible SDK creator
+export { createZapierSdk, createSdk, ZapierSdkOptions } from "./sdk";
 
 // Export SDK types from types (not sdk.ts to avoid circular imports)
-export type { BaseZapierSdk, ZapierSdk } from "./types/sdk";
+export type { FunctionRegistryEntry } from "./types/sdk";
+
+// Export plugin utilities and SDK types
+export type {
+  Plugin,
+  PluginProvides,
+  PluginDependencies,
+  PluginOptions,
+  GetSdkType,
+  Sdk,
+} from "./types/plugin";
+
+// Export ZapierSdk from sdk.ts (it's now ReturnType<typeof createZapierSdk>)
+export type { ZapierSdk } from "./types/sdk";

package/src/plugins/api/index.ts

@@ -0,0 +1,47 @@
+import { createZapierApi } from "../../api";
+import type { ApiClient } from "../../api/types";
+import type { BaseSdkOptions } from "../../types/sdk";
+import type { Plugin } from "../../types/plugin";
+
+export interface ApiPluginOptions extends BaseSdkOptions {}
+
+// API plugin only provides context, no SDK methods
+export interface ApiPluginProvides {
+  context: {
+    api: ApiClient;
+  };
+}
+
+// API plugin requires no context and provides api in context
+export const apiPlugin: Plugin<
+  {}, // no SDK dependencies
+  {}, // requires no context
+  ApiPluginProvides
+> = (params) => {
+  // Extract all options - everything passed to the plugin
+  const {
+    fetch: customFetch = globalThis.fetch,
+    baseUrl = "https://zapier.com",
+    token,
+    getToken,
+    onEvent,
+    debug = false,
+  } = params as any;
+
+  // Create the API client - it will handle token resolution internally
+  const api = createZapierApi({
+    baseUrl,
+    token,
+    getToken,
+    debug,
+    fetch: customFetch,
+    onEvent,
+  });
+
+  // Return flat structure with context only
+  return {
+    context: {
+      api, // Provide API client in context for other plugins to use
+    },
+  };
+};

package/src/plugins/apps/index.ts

@@ -1,12 +1,16 @@
-import {
-  ActionExecutionOptions,
-  ActionExecutionResult,
-} from "../../types/domain";
+import { ActionExecutionOptions } from "./types";
 import type { ActionProxy } from "./types";
-import type { ZapierSdk } from "../../types/sdk";
+import { ZapierValidationError } from "../../types/errors";
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { FetchPluginProvides } from "../fetch/index";
+import type { RunActionPluginProvides } from "../runAction/index";
 
-export interface AppsPluginOptions {
-  sdk: ZapierSdk;
+export interface AppsPluginProvides {
+  apps: ActionProxy;
+}
+
+interface AppsPluginOptions {
+  sdk: GetSdkType<FetchPluginProvides & RunActionPluginProvides>;
 }
 
 interface AppFactoryOptions {
@@ -20,9 +24,7 @@ function createActionFunction(
   options: AppsPluginOptions,
   pinnedAuthId?: number,
 ) {
-  return async (
-    actionOptions: ActionExecutionOptions = {},
-  ): Promise<ActionExecutionResult> => {
+  return (actionOptions: ActionExecutionOptions = {}): any => {
     const { sdk } = options;
     const { inputs, authenticationId: providedAuthenticationId } =
       actionOptions;
@@ -31,7 +33,7 @@ function createActionFunction(
     const authenticationId = pinnedAuthId || providedAuthenticationId;
 
     if (!authenticationId) {
-      throw new Error(
+      throw new ZapierValidationError(
         `Authentication ID is required. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }) or provide authenticationId in the action call.`,
       );
     }
@@ -55,29 +57,28 @@ function createActionTypeProxy(
 ) {
   // Special handling for "fetch" action type
   if (actionType === "fetch") {
-    return async (fetchOptions: {
-      url: string;
-      method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
-      body?: string;
-      headers?: Record<string, string>;
-      callbackUrl?: string;
-      authenticationTemplate?: string;
-      authenticationId?: number;
-    }) => {
+    return async (
+      url: string | URL,
+      init?: RequestInit & {
+        authenticationId?: number;
+        callbackUrl?: string;
+        authenticationTemplate?: string;
+      },
+    ) => {
       const { sdk } = options;
 
       // Use pinned auth ID first, then provided auth ID
-      const authenticationId = pinnedAuthId || fetchOptions.authenticationId;
+      const authenticationId = pinnedAuthId || init?.authenticationId;
 
       if (!authenticationId) {
-        throw new Error(
+        throw new ZapierValidationError(
           `Authentication ID is required for fetch. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }).fetch(...) or provide authenticationId in the fetch call.`,
         );
       }
 
       // Call sdk.fetch with the resolved authenticationId
-      return sdk.fetch({
-        ...fetchOptions,
+      return sdk.fetch(url, {
+        ...init,
         authenticationId,
       });
     };
@@ -161,10 +162,14 @@ function createAppsProxy(options: AppsPluginOptions): ActionProxy {
   return appsProxy;
 }
 
-// Export the plugin creation function
-export function createAppsPlugin(options: AppsPluginOptions): ActionProxy {
-  return createAppsProxy(options);
-}
-
-// Re-export types
-export type { ActionProxy, AppsPluginSdkExtension } from "./types";
+// Direct plugin function - takes options + sdk + context in one object
+export const appsPlugin: Plugin<
+  GetSdkType<FetchPluginProvides & RunActionPluginProvides>, // requires fetch + runAction in SDK
+  {}, // no context requirements
+  AppsPluginProvides
+> = ({ sdk }) => {
+  // Return flat structure - apps goes directly to SDK
+  return {
+    apps: createAppsProxy({ sdk }),
+  };
+};

package/src/plugins/apps/types.ts

@@ -1,18 +1,33 @@
-import type {
-  ActionExecutionOptions,
-  ActionExecutionResult,
-} from "../../types/domain";
+// Apps plugin-specific execution options
+export interface ActionExecutionOptions {
+  inputs?: Record<string, any>;
+  authenticationId?: number;
+}
 
 interface AppFactoryOptions {
   authenticationId: number;
 }
 
-interface ActionTypeProxy {
-  [action: string]: (
-    options?: ActionExecutionOptions,
-  ) => Promise<ActionExecutionResult>;
+// Base action type proxy for regular actions
+interface BaseActionTypeProxy {
+  [action: string]: (options?: ActionExecutionOptions) => any;
+}
+
+// Special fetch function type
+interface FetchActionType {
+  fetch: (
+    url: string | URL,
+    init?: RequestInit & {
+      authenticationId?: number;
+      callbackUrl?: string;
+      authenticationTemplate?: string;
+    },
+  ) => Promise<Response>;
 }
 
+// Combined action type proxy
+type ActionTypeProxy = BaseActionTypeProxy & Partial<FetchActionType>;
+
 interface AppProxy {
   [type: string]: ActionTypeProxy;
 }
@@ -28,7 +43,4 @@ export interface ActionProxy {
   [app: string]: AppProxyWithFactory;
 }
 
-// Plugin interface - ready to be mixed into main SDK interface
-export interface AppsPluginSdkExtension {
-  apps: ActionProxy;
-}
+// Note: AppsPluginSdkExtension removed - now using AppsPluginProvides in index.ts

package/src/plugins/fetch/index.ts

@@ -0,0 +1,58 @@
+import { RelayRequestOptions } from "../request/schemas";
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { RequestPluginProvides } from "../request";
+
+export interface FetchPluginProvides {
+  fetch: (
+    url: string | URL,
+    init?: RequestInit & {
+      authenticationId?: number;
+      callbackUrl?: string;
+      authenticationTemplate?: string;
+    },
+  ) => Promise<Response>;
+}
+
+/**
+ * Direct plugin function - takes options + sdk + context in one object
+ */
+export const fetchPlugin: Plugin<
+  GetSdkType<RequestPluginProvides>, // requires request in SDK
+  {}, // requires no context (uses SDK methods)
+  FetchPluginProvides
+> = ({ sdk }) => {
+  // Return flat structure - fetch goes directly to SDK
+  return {
+    fetch: async function fetch(
+      url: string | URL,
+      init?: RequestInit & {
+        authenticationId?: number;
+        callbackUrl?: string;
+        authenticationTemplate?: string;
+      },
+    ): Promise<Response> {
+      const {
+        authenticationId,
+        callbackUrl,
+        authenticationTemplate,
+        ...fetchInit
+      } = init || {};
+
+      return sdk.request({
+        url: url.toString(),
+        method: fetchInit.method as RelayRequestOptions["method"],
+        body: fetchInit.body,
+        headers: fetchInit.headers,
+        authenticationId,
+        callbackUrl,
+        authenticationTemplate,
+      });
+    },
+  };
+};
+
+export type ZapierFetchInitOptions = RequestInit & {
+  authenticationId?: number;
+  callbackUrl?: string;
+  authenticationTemplate?: string;
+};