@zapier/zapier-sdk 0.0.3 → 0.1.1

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 → listAuthentications/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 { ListAuthenticationsOptions } from "./schemas";
 
 /**
  * List available authentications with optional filtering
@@ -23,8 +15,8 @@ export interface ListAuthsOptions extends FunctionConfig {
  * @param options - Filtering, pagination, and API configuration options
  * @returns Promise<Authentication[]> with pagination metadata
  */
-export async function listAuths(
-  options: ListAuthsOptions = {},
+export async function listAuthentications(
+  options: Partial<ListAuthenticationsOptions> = {},
 ): Promise<Authentication[]> {
   const { token } = options;
 
@@ -37,8 +29,8 @@ export async function listAuths(
   const api = getOrCreateApiClient(options);
 
   // Local function to handle the actual API fetching
-  const listAuthsInternal = async (
-    options: ListAuthsOptions = {},
+  const listAuthenticationsInternal = async (
+    options: ListAuthenticationsOptions = {},
   ): Promise<Authentication[]> => {
     // Build search parameters
     const searchParams: Record<string, string> = {};
@@ -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,
@@ -76,6 +68,12 @@ export async function listAuths(
     }
 
     // Add other query parameters if provided
+    // Use title as search if no explicit search provided
+    if (options.search) {
+      searchParams.search = options.search;
+    } else if (options.title) {
+      searchParams.search = options.title;
+    }
     if (options.account_id) {
       searchParams.account_id = options.account_id;
     }
@@ -110,7 +108,18 @@ export async function listAuths(
     );
 
     // Transform API response
-    const auths = data.results || [];
+    let auths = data.results || [];
+
+    // Coerce title from label if title is missing (API cleanup)
+    auths = auths.map((auth) => ({
+      ...auth,
+      title: auth.title || (auth as any).label || undefined,
+    }));
+
+    // Filter by exact title match if specified
+    if (options.title) {
+      auths = auths.filter((auth) => auth.title === options.title);
+    }
 
     // Add pagination metadata to the response
     if (auths.length > 0) {
@@ -129,7 +138,7 @@ export async function listAuths(
   // If a limit is provided and no specific owner filter, prioritize owned auths
   if (options.limit && options.owner === undefined) {
     // First get owned auths
-    const ownedAuths = await listAuthsInternal({
+    const ownedAuths = await listAuthenticationsInternal({
       ...options,
       owner: "me",
     });
@@ -140,15 +149,15 @@ export async function listAuths(
     }
 
     // Get all auths up to the original limit to fill remaining slots
-    const allAuths = await listAuthsInternal({
+    const allAuths = await listAuthenticationsInternal({
       ...options,
       owner: undefined,
     });
 
     // 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
@@ -157,5 +166,5 @@ export async function listAuths(
   }
 
   // Standard implementation for non-prioritized requests
-  return listAuthsInternal(options);
+  return listAuthenticationsInternal(options);
 }

package/src/functions/listAuthentications/info.ts

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

package/src/functions/listAuthentications/schemas.ts

@@ -0,0 +1,60 @@
+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 ListAuthenticationsSchema = 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("List available authentications with optional filtering"),
+  AuthItemSchema,
+);
+
+// Type inferred from schema + function config
+export type ListAuthenticationsOptions = z.infer<
+  typeof ListAuthenticationsSchema
+> & {
+  /** 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 ListAuthenticationsSdkFunction {
+  listAuthentications: (
+    options?: Partial<ListAuthenticationsOptions>,
+  ) => 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,9 +1,20 @@
-// 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 schema utilities for CLI
+export { isPositional } from "./schema-utils";
+
+// 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";
+export { listAuthentications } from "./functions/listAuthentications";
+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";
@@ -14,4 +25,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";