@zapier/zapier-sdk 0.0.3 → 0.1.0

package/src/functions/{getApp.ts → getApp/index.ts}

@@ -1,9 +1,7 @@
-import { getOrCreateApiClient } from "../api";
-import type { Integration, FunctionConfig } from "../types";
-
-export interface GetAppOptions extends FunctionConfig {
-  key: string;
-}
+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
@@ -17,18 +15,12 @@ export interface GetAppOptions extends FunctionConfig {
 export async function getApp(options: GetAppOptions): Promise<Integration> {
   const api = getOrCreateApiClient(options);
 
-  const { key } = options;
+  const { appKey } = options;
 
-  const app = await api.get(`/api/v4/apps/${key}/`, {
+  const app = await api.get(`/api/v4/apps/${appKey}/`, {
     customErrorHandler: (response) => {
       if (response.status === 404) {
-        const AppNotFoundError = class extends Error {
-          constructor(appKey: string) {
-            super(`App not found: ${appKey}`);
-            this.name = "AppNotFoundError";
-          }
-        };
-        return new AppNotFoundError(key);
+        return new AppNotFoundError(appKey);
       }
       return undefined;
     },
@@ -45,3 +37,5 @@ export async function getApp(options: GetAppOptions): Promise<Integration> {
     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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { AppKeyPropertySchema } from "../../types/properties";
+import type { Integration } 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> & {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+};
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface GetAppSdkFunction {
+  getApp: (options: GetAppOptions) => Promise<Integration>;
+}

package/src/functions/{listActions.ts → listActions/index.ts}

@@ -1,11 +1,7 @@
-import { getOrCreateApiClient } from "../api";
-import type { Action, FunctionConfig } from "../types";
-import { getApp } from "./getApp";
-
-export interface ListActionsOptions extends FunctionConfig {
-  appKey?: string;
-  type?: string;
-}
+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
@@ -17,7 +13,7 @@ export interface ListActionsOptions extends FunctionConfig {
  * @returns Promise<Action[]> with pagination metadata
  */
 export async function listActions(
-  options: ListActionsOptions = {},
+  options: Partial<ListActionsOptions> = {},
 ): Promise<Action[]> {
   const api = getOrCreateApiClient(options);
 
@@ -26,7 +22,7 @@ export async function listActions(
     try {
       // Use the standalone getApp function
       const appData = await getApp({
-        key: options.appKey,
+        appKey: options.appKey,
         api,
         token: options.token,
         baseUrl: options.baseUrl,
@@ -149,3 +145,5 @@ export async function listActions(
 
   return actions;
 }
+
+// No registry info here - moved to info.ts for proper tree-shaking

package/src/functions/listActions/info.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import {
+  AppKeyPropertySchema,
+  ActionTypePropertySchema,
+} from "../../types/properties";
+import { withOutputSchema } from "../../schema-utils";
+import { ActionItemSchema } from "../../schemas/Action";
+import type { Action } 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> & {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+};
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface ListActionsSdkFunction {
+  listActions: (options?: Partial<ListActionsOptions>) => Promise<Action[]>;
+}

package/src/functions/{listApps.ts → listApps/index.ts}

@@ -1,11 +1,6 @@
-import { getOrCreateApiClient } from "../api";
-import type { Integration, FunctionConfig } from "../types";
-
-export interface ListAppsOptions extends FunctionConfig {
-  category?: string;
-  limit?: number;
-  offset?: number;
-}
+import { getOrCreateApiClient } from "../../api";
+import type { Integration } from "../../types/domain";
+import type { ListAppsOptions } from "./schemas";
 
 /**
  * List available apps with optional filtering

package/src/functions/listApps/info.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import {
+  LimitPropertySchema,
+  OffsetPropertySchema,
+} from "../../types/properties";
+import { withOutputSchema } from "../../schema-utils";
+import { AppItemSchema } from "../../schemas/App";
+import type { Integration } 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> & {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+};
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface ListAppsSdkFunction {
+  listApps: (options?: Partial<ListAppsOptions>) => Promise<Integration[]>;
+}

package/src/functions/{listAuths.ts → listAuths/index.ts}

@@ -1,18 +1,10 @@
-import { getOrCreateApiClient } from "../api";
+import { getOrCreateApiClient } from "../../api";
 import type {
   Authentication,
   AuthenticationsResponse,
-  FunctionConfig,
-} from "../types";
-import { getApp } from "./getApp";
-
-export interface ListAuthsOptions extends FunctionConfig {
-  appKey?: string;
-  account_id?: string;
-  owner?: string;
-  limit?: number;
-  offset?: number;
-}
+} from "../../types/domain";
+import { getApp } from "../getApp";
+import type { ListAuthsOptions } from "./schemas";
 
 /**
  * List available authentications with optional filtering
@@ -24,7 +16,7 @@ export interface ListAuthsOptions extends FunctionConfig {
  * @returns Promise<Authentication[]> with pagination metadata
  */
 export async function listAuths(
-  options: ListAuthsOptions = {},
+  options: Partial<ListAuthsOptions> = {},
 ): Promise<Authentication[]> {
   const { token } = options;
 
@@ -48,7 +40,7 @@ export async function listAuths(
       try {
         // Use the standalone getApp function
         const app = await getApp({
-          key: options.appKey,
+          appKey: options.appKey,
           api,
           token: options.token,
           baseUrl: options.baseUrl,
@@ -146,9 +138,9 @@ export async function listAuths(
     });
 
     // Filter out auths the user already owns to avoid duplicates
-    const ownedAuthIds = new Set(ownedAuths.map((auth) => auth.id));
+    const ownedAuthenticationIds = new Set(ownedAuths.map((auth) => auth.id));
     const additionalAuths = allAuths.filter(
-      (auth) => !ownedAuthIds.has(auth.id),
+      (auth) => !ownedAuthenticationIds.has(auth.id),
     );
 
     // Combine and slice to the requested limit

package/src/functions/listAuths/info.ts

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

package/src/functions/listAuths/schemas.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import {
+  AppKeyPropertySchema,
+  LimitPropertySchema,
+  OffsetPropertySchema,
+} from "../../types/properties";
+import { withOutputSchema } from "../../schema-utils";
+import { AuthItemSchema } from "../../schemas/Auth";
+import type { Authentication } from "../../types/domain";
+
+// Pure Zod schema - no resolver metadata!
+export const ListAuthsSchema = withOutputSchema(
+  z
+    .object({
+      appKey: AppKeyPropertySchema.optional().describe(
+        "App slug to get authentications for (e.g., 'slack', 'github')",
+      ),
+      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("List available authentications with optional filtering"),
+  AuthItemSchema,
+);
+
+// Type inferred from schema + function config
+export type ListAuthsOptions = z.infer<typeof ListAuthsSchema> & {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+};
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface ListAuthsSdkFunction {
+  listAuths: (options?: Partial<ListAuthsOptions>) => Promise<Authentication[]>;
+}

package/src/functions/{listFields.ts → listFields/index.ts}

@@ -1,19 +1,11 @@
-import { getOrCreateApiClient } from "../api";
+import { getOrCreateApiClient } from "../../api";
 import type {
   ActionField,
   NeedsRequest,
   NeedsResponse,
-  FunctionConfig,
-} from "../types";
-import { getApp } from "./getApp";
-
-export interface ListFieldsOptions extends FunctionConfig {
-  app: string;
-  action: string;
-  type: string;
-  authId?: number;
-  params?: Record<string, any>;
-}
+} from "../../types/domain";
+import { getApp } from "../getApp";
+import type { ListFieldsOptions } from "./schemas";
 
 /**
  * List available fields for an action
@@ -21,7 +13,7 @@ export interface ListFieldsOptions extends FunctionConfig {
  * 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 - Action details, auth ID, params, and API configuration options
+ * @param options - Action details, authentication ID, params, and API configuration options
  * @returns Promise<ActionField[]>
  */
 export async function listFields(
@@ -29,15 +21,12 @@ export async function listFields(
 ): Promise<ActionField[]> {
   const api = getOrCreateApiClient(options);
 
-  // Map consistent parameter names to internal API names
-  const { app, action, type, authId, params } = options;
-  const appKey = app;
-  const actionKey = action;
-  const actionType = type;
+  // Extract parameters
+  const { appKey, actionKey, actionType, authenticationId, params } = options;
 
   // Use the standalone getApp function
   const appData = await getApp({
-    key: appKey,
+    appKey,
     api,
     token: options.token,
     baseUrl: options.baseUrl,
@@ -55,7 +44,7 @@ export async function listFields(
     selected_api: selectedApi,
     action: actionKey,
     type_of: actionType,
-    authentication_id: authId,
+    authentication_id: authenticationId,
     params: params || {},
   };
 
@@ -93,3 +82,5 @@ export async function listFields(
     inputFormat: need.input_format,
   }));
 }
+
+// No registry info here - moved to info.ts for proper tree-shaking

package/src/functions/listFields/info.ts

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

package/src/functions/listFields/schemas.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import {
+  AppKeyPropertySchema,
+  ActionTypePropertySchema,
+  ActionKeyPropertySchema,
+  AuthenticationIdPropertySchema,
+  ParamsPropertySchema,
+} from "../../types/properties";
+import { withOutputSchema } from "../../schema-utils";
+import { FieldItemSchema } from "../../schemas/Field";
+import type { ActionField } from "../../types/domain";
+
+// Pure Zod schema - no resolver metadata!
+export const ListFieldsSchema = withOutputSchema(
+  z
+    .object({
+      appKey: AppKeyPropertySchema,
+      actionType: ActionTypePropertySchema,
+      actionKey: ActionKeyPropertySchema,
+      authenticationId: AuthenticationIdPropertySchema.optional(),
+      params: ParamsPropertySchema.optional().describe(
+        "Additional parameters that may affect available fields",
+      ),
+    })
+    .describe("Get the input fields required for a specific action"),
+  FieldItemSchema,
+);
+
+// Type inferred from schema + function config
+export type ListFieldsOptions = z.infer<typeof ListFieldsSchema> & {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+};
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface ListFieldsSdkFunction {
+  listFields: (options: ListFieldsOptions) => Promise<ActionField[]>;
+}

package/src/functions/{runAction.ts → runAction/index.ts}

@@ -1,15 +1,8 @@
-import { getOrCreateApiClient, generateRequestId } from "../api";
-import type { ActionExecutionResult, FunctionConfig } from "../types";
-import { getAction } from "./getAction";
-import { getApp } from "./getApp";
-
-export interface RunActionOptions extends FunctionConfig {
-  app: string;
-  type: string;
-  action: string;
-  inputs?: Record<string, any>;
-  authId?: number;
-}
+import { getOrCreateApiClient, generateRequestId } from "../../api";
+import type { ActionExecutionResult } from "../../types/domain";
+import { getAction } from "../getAction";
+import { getApp } from "../getApp";
+import type { RunActionOptions } from "./schemas";
 
 /**
  * Execute an action
@@ -23,7 +16,14 @@ export interface RunActionOptions extends FunctionConfig {
 export async function runAction(
   options: RunActionOptions,
 ): Promise<ActionExecutionResult> {
-  const { app, type, action, inputs, authId: providedAuthId, token } = options;
+  const {
+    appKey,
+    actionType,
+    actionKey,
+    inputs,
+    authenticationId: providedAuthenticationId,
+    token,
+  } = options;
 
   if (!token && !process.env.ZAPIER_TOKEN) {
     throw new Error(
@@ -36,15 +36,15 @@ export async function runAction(
   // Validate that the action exists
   const actionData = await getAction({
     ...options,
-    app: app,
-    action: action,
-    type: type,
+    appKey: appKey,
+    actionKey: actionKey,
+    actionType: actionType,
   });
 
   // Validate action type matches
-  if (actionData.type !== type) {
+  if (actionData.type !== actionType) {
     throw new Error(
-      `Action type mismatch: expected ${type}, got ${actionData.type}`,
+      `Action type mismatch: expected ${actionType}, got ${actionData.type}`,
     );
   }
 
@@ -52,12 +52,12 @@ export async function runAction(
   const startTime = Date.now();
   const result = await executeActionWithStrategy({
     api,
-    appSlug: app,
-    actionKey: action,
+    appSlug: appKey,
+    actionKey: actionKey,
     actionType: actionData.type,
     executionOptions: { inputs: inputs || {} },
     auth: token
-      ? { token: token, authentication_id: providedAuthId }
+      ? { token: token, authentication_id: providedAuthenticationId }
       : undefined,
     options,
   });
@@ -150,7 +150,7 @@ async function executeActionViaActionsApi(
 
   // Use the standalone getApp function
   const appData = await getApp({
-    key: appSlug,
+    appKey: appSlug,
     api,
     token: options.token,
     baseUrl: options.baseUrl,
@@ -216,7 +216,7 @@ async function executeActionViaInvokeApi(
 
   // Use the standalone getApp function
   const appData = await getApp({
-    key: appSlug,
+    appKey: appSlug,
     api,
     token: options.token,
     baseUrl: options.baseUrl,
@@ -254,3 +254,5 @@ async function executeActionViaInvokeApi(
     resultExtractor: (result: any) => result.results || result,
   });
 }
+
+// No registry info here - moved to info.ts for proper tree-shaking

package/src/functions/runAction/info.ts

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

package/src/functions/runAction/schemas.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import {
+  AppKeyPropertySchema,
+  ActionTypePropertySchema,
+  ActionKeyPropertySchema,
+  AuthenticationIdPropertySchema,
+  InputsPropertySchema,
+} from "../../types/properties";
+import type { ActionExecutionResult } from "../../types/domain";
+
+// Pure Zod schema - no resolver metadata!
+export const RunActionSchema = z
+  .object({
+    appKey: AppKeyPropertySchema,
+    actionType: ActionTypePropertySchema,
+    actionKey: ActionKeyPropertySchema,
+    inputs: InputsPropertySchema.optional().describe(
+      "Input parameters for the action",
+    ),
+    authenticationId: AuthenticationIdPropertySchema.optional(),
+  })
+  .describe("Execute an action with the given inputs");
+
+// Type inferred from schema + function config
+export type RunActionOptions = z.infer<typeof RunActionSchema> & {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+};
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface RunActionSdkFunction {
+  runAction: (options: RunActionOptions) => Promise<ActionExecutionResult>;
+}

package/src/index.ts

@@ -1,6 +1,12 @@
-// Export everything from types and actions-sdk
-export * from "./types";
-export * from "./actions-sdk";
+// Export everything from types and plugins
+export * from "./types/domain";
+export * from "./types/properties";
+export * from "./plugins/apps";
+
+// Export resolvers for CLI use
+export * from "./resolvers";
+
+// Note: SdkSchemas is now available via SDK.__registry
 
 // Export individual functions for tree-shaking
 export { listAuths } from "./functions/listAuths";
@@ -14,4 +20,7 @@ export { generateTypes } from "./functions/generateTypes";
 export { bundleCode } from "./functions/bundleCode";
 
 // Export the main combined SDK
-export { createZapierSdk, ZapierSdk, ZapierSdkOptions } from "./sdk";
+export { createZapierSdk, ZapierSdkOptions } from "./sdk";
+
+// Export SDK type from types (not sdk.ts to avoid circular imports)
+export type { ZapierSdk } from "./types/sdk";