@zapier/zapier-sdk 0.0.3 → 0.1.0

package/dist/schemas/Auth.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthItemSchema = void 0;
+const zod_1 = require("zod");
+const schema_utils_1 = require("../schema-utils");
+// ============================================================================
+// Auth Schemas
+// ============================================================================
+exports.AuthItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
+    id: zod_1.z.number(),
+    title: zod_1.z.string().optional(),
+    label: zod_1.z.string().optional(),
+    identifier: zod_1.z.string().optional(),
+    account_id: zod_1.z.string().optional(),
+    is_private: zod_1.z.boolean().optional(),
+    shared_with_all: zod_1.z.boolean().optional(),
+    marked_stale_at: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        if (item.identifier) {
+            details.push({
+                text: `Identifier: ${item.identifier}`,
+                style: "accent",
+            });
+        }
+        if (item.label && item.title && item.label !== item.title) {
+            details.push({
+                text: `Label: ${item.label}`,
+                style: "normal",
+            });
+        }
+        details.push({
+            text: `Account: ${item.account_id || "unknown"} | Private: ${item.is_private || false} | Shared: ${item.shared_with_all || false}`,
+            style: "dim",
+        });
+        if (item.marked_stale_at) {
+            details.push({
+                text: `⚠️  Marked stale: ${new Date(item.marked_stale_at).toLocaleDateString()}`,
+                style: "warning",
+            });
+        }
+        return {
+            title: item.title || item.label || `Authentication ${item.id}`,
+            subtitle: `(ID: ${item.id})`,
+            details,
+        };
+    },
+});

package/dist/schemas/Field.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const FieldItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+}, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+}>;
+export type FieldItem = z.infer<typeof FieldItemSchema>;

package/dist/schemas/Field.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldItemSchema = void 0;
+const zod_1 = require("zod");
+const schema_utils_1 = require("../schema-utils");
+// ============================================================================
+// Field Schemas
+// ============================================================================
+exports.FieldItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
+    key: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        if (item.description) {
+            details.push({ text: item.description, style: "dim" });
+        }
+        return {
+            title: item.name || item.key,
+            subtitle: `(${item.key})`,
+            details,
+        };
+    },
+});

package/dist/sdk.d.ts

@@ -1,7 +1,6 @@
-import { ActionsSdk } from "./actions-sdk";
-import { BaseSdkOptions } from "./types";
-export interface ZapierSdk extends ActionsSdk {
-}
+import { BaseSdkOptions } from "./types/domain";
+import type { ZapierSdk } from "./types/sdk";
+export type { ZapierSdk } from "./types/sdk";
 export interface ZapierSdkOptions extends BaseSdkOptions {
 }
 export declare function createZapierSdk(options?: ZapierSdkOptions): ZapierSdk;

package/dist/sdk.js

@@ -1,17 +1,102 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createZapierSdk = createZapierSdk;
-const actions_sdk_1 = require("./actions-sdk");
+const api_1 = require("./api");
+// Import function implementations
+const listApps_1 = require("./functions/listApps");
+const getApp_1 = require("./functions/getApp");
+const listActions_1 = require("./functions/listActions");
+const getAction_1 = require("./functions/getAction");
+const runAction_1 = require("./functions/runAction");
+const listAuths_1 = require("./functions/listAuths");
+const listFields_1 = require("./functions/listFields");
+const generateTypes_1 = require("./functions/generateTypes");
+const bundleCode_1 = require("./functions/bundleCode");
+// Import function registry info objects (only for CLI registry)
+const info_1 = require("./functions/listApps/info");
+const info_2 = require("./functions/getApp/info");
+const info_3 = require("./functions/listActions/info");
+const info_4 = require("./functions/getAction/info");
+const info_5 = require("./functions/runAction/info");
+const info_6 = require("./functions/listAuths/info");
+const info_7 = require("./functions/listFields/info");
+const info_8 = require("./functions/generateTypes/info");
+const info_9 = require("./functions/bundleCode/info");
+// Function registry as array - uses names from function info objects
+const functionRegistry = [
+    info_1.listAppsInfo,
+    info_2.getAppInfo,
+    info_3.listActionsInfo,
+    info_4.getActionInfo,
+    info_5.runActionInfo,
+    info_6.listAuthsInfo,
+    info_7.listFieldsInfo,
+    info_8.generateTypesInfo,
+    info_9.bundleCodeInfo,
+];
+// Import plugin functions
+const index_1 = require("./plugins/apps/index");
+function createBaseZapierSdk(options = {}) {
+    // Auto-load .env files (searches up directory tree)
+    try {
+        const { findUpSync } = require("find-up");
+        const envPath = findUpSync(".env");
+        if (envPath) {
+            require("dotenv").config({ path: envPath, quiet: true });
+        }
+    }
+    catch {
+        // Silently fail if dotenv/find-up not available or .env not found
+    }
+    const { fetch: customFetch = globalThis.fetch, baseUrl = "https://zapier.com", token, debug = false, } = options;
+    // If no token provided, try to get it from environment variable
+    const finalToken = token || process.env.ZAPIER_TOKEN;
+    // Create the API client
+    const api = (0, api_1.createZapierApi)({
+        baseUrl,
+        token: finalToken,
+        debug,
+        fetch: customFetch,
+    });
+    // Build SDK directly - TypeScript will enforce correct implementation
+    const sdk = {
+        // Registry for CLI
+        __registry: functionRegistry,
+        // Function implementations with API config injection
+        listApps: (options = {}) => (0, listApps_1.listApps)({ ...options, api, token: finalToken }),
+        getApp: (options) => (0, getApp_1.getApp)({ ...options, api, token: finalToken }),
+        listActions: (options = {}) => (0, listActions_1.listActions)({ ...options, api, token: finalToken }),
+        getAction: (options) => (0, getAction_1.getAction)({ ...options, api, token: finalToken }),
+        runAction: (options) => (0, runAction_1.runAction)({ ...options, api, token: finalToken }),
+        listAuths: (options = {}) => (0, listAuths_1.listAuths)({ ...options, api, token: finalToken }),
+        listFields: (options) => (0, listFields_1.listFields)({ ...options, api, token: finalToken }),
+        generateTypes: (options) => (0, generateTypes_1.generateTypes)({ ...options, api, token: finalToken }),
+        bundleCode: (options) => (0, bundleCode_1.bundleCode)(options), // No API config needed
+    };
+    return sdk;
+}
 function createZapierSdk(options = {}) {
-    // Create individual SDKs
-    const actionsSdk = (0, actions_sdk_1.createActionsSdk)(options);
-    // For now, we just return the actions SDK
-    // Later we'll combine multiple SDKs here
-    return {
-        ...actionsSdk,
-        // Future SDKs will be spread here:
-        // ...workflowsSdk,
-        // ...interfacesSdk,
-        // ...tablesSdk,
+    // Create base SDK
+    const baseSdk = createBaseZapierSdk(options);
+    // Extract options needed for plugins
+    const { fetch: customFetch = globalThis.fetch, baseUrl = "https://zapier.com", token, debug = false, } = options;
+    const finalToken = token || process.env.ZAPIER_TOKEN;
+    // Create the API client for plugins
+    const api = (0, api_1.createZapierApi)({
+        baseUrl,
+        token: finalToken,
+        debug,
+        fetch: customFetch,
+    });
+    // Create plugins directly - TypeScript will enforce correct implementation
+    const appsPlugin = (0, index_1.createAppsPlugin)({
+        api,
+        token: finalToken,
+    });
+    // Compose final SDK - TypeScript will enforce we have all required properties
+    const fullSdk = {
+        ...baseSdk,
+        apps: appsPlugin,
     };
+    return fullSdk;
 }

package/dist/types/domain.d.ts

@@ -0,0 +1,22 @@
+export type { Integration, Action, Trigger, Field, Choice, ActionExecutionResult, ActionField, ActionFieldChoice, NeedsRequest, NeedsResponse, Authentication, AuthenticationsResponse, } from "../api/types";
+export interface ActionExecutionOptions {
+    inputs?: Record<string, any>;
+    authenticationId?: number;
+}
+export interface AuthObject {
+    id: number;
+}
+export interface BaseSdkOptions {
+    token?: string;
+    fetch?: typeof fetch;
+    baseUrl?: string;
+    debug?: boolean;
+}
+export declare class ZapierSdkError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+export declare class AppNotFoundError extends ZapierSdkError {
+    appKey: string;
+    constructor(appKey: string);
+}

package/dist/types/domain.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppNotFoundError = exports.ZapierSdkError = void 0;
+// Error Classes
+class ZapierSdkError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "ZapierSdkError";
+    }
+}
+exports.ZapierSdkError = ZapierSdkError;
+class AppNotFoundError extends ZapierSdkError {
+    constructor(appKey) {
+        super(`App "${appKey}" not found`);
+        this.name = "AppNotFoundError";
+        this.code = "APP_NOT_FOUND";
+        this.appKey = appKey;
+    }
+}
+exports.AppNotFoundError = AppNotFoundError;

package/dist/types/properties.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const AppKeyPropertySchema: z.ZodString;
+export declare const ActionTypePropertySchema: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+export declare const ActionKeyPropertySchema: z.ZodString;
+export declare const AuthenticationIdPropertySchema: z.ZodNumber;
+export declare const InputsPropertySchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+export declare const LimitPropertySchema: z.ZodDefault<z.ZodNumber>;
+export declare const OffsetPropertySchema: z.ZodDefault<z.ZodNumber>;
+export declare const OutputPropertySchema: z.ZodString;
+export declare const DebugPropertySchema: z.ZodDefault<z.ZodBoolean>;
+export declare const ParamsPropertySchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+export type AppKeyProperty = z.infer<typeof AppKeyPropertySchema>;
+export type ActionTypeProperty = z.infer<typeof ActionTypePropertySchema>;
+export type ActionKeyProperty = z.infer<typeof ActionKeyPropertySchema>;
+export type AuthenticationIdProperty = z.infer<typeof AuthenticationIdPropertySchema>;
+export type InputsProperty = z.infer<typeof InputsPropertySchema>;
+export type LimitProperty = z.infer<typeof LimitPropertySchema>;
+export type OffsetProperty = z.infer<typeof OffsetPropertySchema>;
+export type OutputProperty = z.infer<typeof OutputPropertySchema>;
+export type DebugProperty = z.infer<typeof DebugPropertySchema>;
+export type ParamsProperty = z.infer<typeof ParamsPropertySchema>;

package/dist/types/properties.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamsPropertySchema = exports.DebugPropertySchema = exports.OutputPropertySchema = exports.OffsetPropertySchema = exports.LimitPropertySchema = exports.InputsPropertySchema = exports.AuthenticationIdPropertySchema = exports.ActionKeyPropertySchema = exports.ActionTypePropertySchema = exports.AppKeyPropertySchema = void 0;
+const zod_1 = require("zod");
+// Shared property definitions for common parameters across functions
+// These can be reused in function schemas without duplication
+exports.AppKeyPropertySchema = zod_1.z
+    .string()
+    .min(1)
+    .describe("App slug (e.g., 'slack', 'github')");
+exports.ActionTypePropertySchema = zod_1.z
+    .enum(["read", "write", "search", "create", "update", "delete"])
+    .describe("Action type that matches the action's defined type");
+exports.ActionKeyPropertySchema = zod_1.z
+    .string()
+    .min(1)
+    .describe("Action key to execute");
+exports.AuthenticationIdPropertySchema = zod_1.z
+    .number()
+    .int()
+    .describe("Authentication ID to use for this action");
+exports.InputsPropertySchema = zod_1.z
+    .record(zod_1.z.any())
+    .describe("Input parameters for the action");
+exports.LimitPropertySchema = zod_1.z
+    .number()
+    .int()
+    .min(1)
+    .max(1000)
+    .default(50)
+    .describe("Maximum number of items to return");
+exports.OffsetPropertySchema = zod_1.z
+    .number()
+    .int()
+    .min(0)
+    .default(0)
+    .describe("Number of items to skip for pagination");
+exports.OutputPropertySchema = zod_1.z.string().describe("Output file path");
+exports.DebugPropertySchema = zod_1.z
+    .boolean()
+    .default(false)
+    .describe("Enable debug logging");
+exports.ParamsPropertySchema = zod_1.z
+    .record(zod_1.z.any())
+    .describe("Additional parameters");

package/dist/types/sdk.d.ts

@@ -0,0 +1,21 @@
+import type { ListActionsSdkFunction } from "../functions/listActions/schemas";
+import type { GetActionSdkFunction } from "../functions/getAction/schemas";
+import type { GetAppSdkFunction } from "../functions/getApp/schemas";
+import type { RunActionSdkFunction } from "../functions/runAction/schemas";
+import type { ListFieldsSdkFunction } from "../functions/listFields/schemas";
+import type { ListAuthsSdkFunction } from "../functions/listAuths/schemas";
+import type { GenerateTypesSdkFunction } from "../functions/generateTypes/schemas";
+import type { ListAppsSdkFunction } from "../functions/listApps/schemas";
+import type { BundleCodeSdkFunction } from "../functions/bundleCode/schemas";
+import type { AppsPluginSdkExtension } from "../plugins/apps/types";
+export interface ZapierSdkFunctions extends ListActionsSdkFunction, GetActionSdkFunction, GetAppSdkFunction, RunActionSdkFunction, ListFieldsSdkFunction, ListAuthsSdkFunction, GenerateTypesSdkFunction, ListAppsSdkFunction, BundleCodeSdkFunction {
+}
+export interface ZapierSdkPlugins extends AppsPluginSdkExtension {
+}
+export interface ZapierSdk extends ZapierSdkFunctions, ZapierSdkPlugins {
+    __registry: Array<{
+        name: string;
+        inputSchema: any;
+        implementation: Function;
+    }>;
+}

package/dist/types/sdk.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "Complete Zapier SDK - combines all Zapier SDK packages",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,9 @@
     "typescript": "^5.8.3"
   },
   "scripts": {
-    "build": "tsc --project tsconfig.build.json",
+    "build": "rm -rf dist && tsc --project tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "rebuild": "pnpm clean && pnpm build",
     "dev": "tsc --watch",
     "typecheck": "tsc --project tsconfig.build.json --noEmit"
   }

package/src/api/auth.ts

@@ -0,0 +1,28 @@
+/**
+ * Authentication Utilities
+ *
+ * This module provides utilities for handling authentication tokens,
+ * including JWT detection and authorization header generation.
+ */
+
+export function isJwt(token: string): boolean {
+  // JWT tokens have exactly 3 parts separated by dots
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    return false;
+  }
+
+  // Each part should be base64url encoded (no padding)
+  // Basic validation - each part should be non-empty and contain valid base64url characters
+  const base64UrlPattern = /^[A-Za-z0-9_-]+$/;
+  return parts.every((part) => part.length > 0 && base64UrlPattern.test(part));
+}
+
+export function getAuthorizationHeader(token: string): string {
+  // Check if token is a JWT (has 3 parts separated by dots)
+  if (isJwt(token)) {
+    return `JWT ${token}`;
+  }
+  // Default to Bearer for other token types
+  return `Bearer ${token}`;
+}

package/src/api/client.ts

@@ -0,0 +1,148 @@
+/**
+ * API Client Implementation
+ *
+ * This module contains the core API client implementation, including
+ * HTTP method handlers, response processing, and client factory functions.
+ */
+
+import type {
+  ApiClient,
+  ApiClientOptions,
+  RequestOptions,
+  PollOptions,
+} from "./types";
+import { getAuthorizationHeader } from "./auth";
+import { createDebugLogger, createDebugFetch } from "./debug";
+import { pollUntilComplete } from "./polling";
+
+export function createZapierApi(options: ApiClientOptions): ApiClient {
+  const {
+    baseUrl,
+    token,
+    debug = false,
+    fetch: originalFetch = globalThis.fetch,
+  } = options;
+
+  const debugLog = createDebugLogger(debug);
+  const fetch = createDebugFetch({ originalFetch, debugLog });
+
+  // Helper to build full URLs
+  function buildUrl(
+    path: string,
+    searchParams?: Record<string, string>,
+  ): string {
+    const url = new URL(path, baseUrl);
+    if (searchParams) {
+      Object.entries(searchParams).forEach(([key, value]) => {
+        url.searchParams.set(key, value);
+      });
+    }
+    return url.toString();
+  }
+
+  // Helper to build headers
+  function buildHeaders(options: RequestOptions = {}): Record<string, string> {
+    const headers: Record<string, string> = {
+      ...options.headers,
+    };
+
+    // Add auth header if token provided and not explicitly disabled
+    if (token && options.authRequired !== false) {
+      headers.Authorization = getAuthorizationHeader(token);
+    }
+
+    return headers;
+  }
+
+  // Helper to handle responses
+  async function handleResponse(
+    response: Response,
+    customErrorHandler?: (response: Response) => Error | undefined,
+  ): Promise<any> {
+    if (!response.ok) {
+      // Check for custom error handling first
+      if (customErrorHandler) {
+        const customError = customErrorHandler(response);
+        if (customError) {
+          throw customError;
+        }
+      }
+
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    // Try to parse JSON, fall back to text if that fails
+    try {
+      return await response.json();
+    } catch {
+      return await response.text();
+    }
+  }
+
+  // Helper to perform HTTP requests with JSON handling
+  async function fetchJson(
+    method: string,
+    path: string,
+    data?: any,
+    options: RequestOptions = {},
+  ): Promise<any> {
+    const url = buildUrl(path, options.searchParams);
+    const headers = buildHeaders(options);
+
+    // Add Content-Type for JSON requests with body data
+    if (data && typeof data === "object") {
+      headers["Content-Type"] = "application/json";
+    }
+
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: data ? JSON.stringify(data) : undefined,
+    });
+
+    return handleResponse(response, options.customErrorHandler);
+  }
+
+  return {
+    async get(path: string, options: RequestOptions = {}): Promise<any> {
+      return fetchJson("GET", path, undefined, options);
+    },
+
+    async post(
+      path: string,
+      data?: any,
+      options: RequestOptions = {},
+    ): Promise<any> {
+      return fetchJson("POST", path, data, options);
+    },
+
+    async put(
+      path: string,
+      data?: any,
+      options: RequestOptions = {},
+    ): Promise<any> {
+      return fetchJson("PUT", path, data, options);
+    },
+
+    async delete(path: string, options: RequestOptions = {}): Promise<any> {
+      return fetchJson("DELETE", path, undefined, options);
+    },
+
+    async poll(path: string, options: PollOptions = {}): Promise<any> {
+      const url = buildUrl(path, options.searchParams);
+      const headers = buildHeaders(options);
+
+      return pollUntilComplete({
+        fetch,
+        url,
+        headers,
+        maxAttempts: options.maxAttempts,
+        initialDelay: options.initialDelay,
+        maxDelay: options.maxDelay,
+        successStatus: options.successStatus,
+        pendingStatus: options.pendingStatus,
+        resultExtractor: options.resultExtractor,
+      });
+    },
+  };
+}

package/src/api/debug.ts

@@ -0,0 +1,58 @@
+/**
+ * Debug Logging Utilities
+ *
+ * This module provides debug logging capabilities for API requests and responses,
+ * including request timing and detailed logging of HTTP interactions.
+ */
+
+import type { DebugLogger } from "./types";
+
+export function createDebugLogger(enabled: boolean): DebugLogger {
+  if (!enabled) {
+    return () => {}; // No-op function when debug is disabled
+  }
+
+  return (message: string, data?: any) => {
+    console.log(`[Zapier SDK] ${message}`, data || "");
+  };
+}
+
+export function createDebugFetch(options: {
+  originalFetch: typeof globalThis.fetch;
+  debugLog: DebugLogger;
+}) {
+  const { originalFetch, debugLog } = options;
+  return async (input: RequestInfo | URL, options?: RequestInit) => {
+    const startTime = Date.now();
+
+    // Convert input to URL string for logging
+    const url = typeof input === "string" ? input : input.toString();
+    const method = options?.method || "GET";
+
+    debugLog(`→ ${method} ${url}`, {
+      headers: options?.headers,
+      body: options?.body ? JSON.parse(options.body as string) : undefined,
+    });
+
+    try {
+      const response = await originalFetch(input, options);
+      const duration = Date.now() - startTime;
+
+      debugLog(`← ${response.status} ${response.statusText} (${duration}ms)`, {
+        url,
+        method,
+        status: response.status,
+      });
+
+      return response;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      debugLog(`✖ Request failed (${duration}ms)`, {
+        url,
+        method,
+        error: error instanceof Error ? error.message : error,
+      });
+      throw error;
+    }
+  };
+}