@zapier/zapier-sdk 0.0.1 → 0.0.3

package/dist/sdk.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createZapierSDK = createZapierSDK;
-const dist_1 = require("../../actions-sdk/dist");
-function createZapierSDK(options = {}) {
+exports.createZapierSdk = createZapierSdk;
+const actions_sdk_1 = require("./actions-sdk");
+function createZapierSdk(options = {}) {
     // Create individual SDKs
-    const actionsSDK = (0, dist_1.createActionsSDK)(options);
+    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,
+        ...actionsSdk,
         // Future SDKs will be spread here:
-        // ...workflowsSDK,
-        // ...interfacesSDK,
-        // ...tablesSDK,
+        // ...workflowsSdk,
+        // ...interfacesSdk,
+        // ...tablesSdk,
     };
 }

package/dist/types.d.ts

@@ -0,0 +1,196 @@
+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: "create" | "update" | "search" | "delete" | "read";
+    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 ListOptions {
+    category?: string;
+    appKey?: string;
+    type?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface ActionExecutionOptions {
+    inputs?: Record<string, any>;
+    authId?: number;
+}
+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 Workflow {
+    id: string;
+    name: string;
+    description: string;
+    steps: WorkflowStep[];
+}
+export interface WorkflowStep {
+    id: string;
+    type: "trigger" | "action";
+    appKey: string;
+    actionKey?: string;
+    triggerKey?: string;
+}
+export interface Interface {
+    key: string;
+    name: string;
+    fields: Field[];
+}
+export interface Table {
+    key: string;
+    name: string;
+    columns: TableColumn[];
+}
+export interface TableColumn {
+    key: string;
+    name: string;
+    type: 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[];
+}
+export interface AuthenticationListOptions {
+    account_id?: string;
+    owner?: string;
+    appKey?: string;
+    limit?: number;
+    offset?: number;
+}
+export declare class ZapierSdkError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+export declare class AppNotFoundError extends ZapierSdkError {
+    constructor(appKey: string);
+}
+export declare class ActionNotFoundError extends ZapierSdkError {
+    constructor(appKey: string, actionKey: string);
+}
+export declare class AuthenticationError extends ZapierSdkError {
+    constructor(message: string);
+}
+export interface AuthObject {
+    id: number;
+}
+export interface BaseSdkOptions {
+    token?: string;
+    authentications?: {
+        [appKey: string]: AuthObject[];
+    };
+    fetch?: typeof fetch;
+    baseUrl?: string;
+    debug?: boolean;
+}
+export interface FunctionConfig {
+    /** 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;
+}
+export interface CombinedSdk {
+    [namespace: string]: any;
+}
+export type SdkFactory<T = any> = (options: BaseSdkOptions) => T;
+export declare function combineSdks(sdks: Record<string, any>): CombinedSdk;

package/dist/types.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationError = exports.ActionNotFoundError = exports.AppNotFoundError = exports.ZapierSdkError = void 0;
+exports.combineSdks = combineSdks;
+// Custom error classes for better error handling
+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";
+    }
+}
+exports.AppNotFoundError = AppNotFoundError;
+class ActionNotFoundError extends ZapierSdkError {
+    constructor(appKey, actionKey) {
+        super(`Action "${actionKey}" not found in app "${appKey}"`);
+        this.name = "ActionNotFoundError";
+        this.code = "ACTION_NOT_FOUND";
+    }
+}
+exports.ActionNotFoundError = ActionNotFoundError;
+class AuthenticationError extends ZapierSdkError {
+    constructor(message) {
+        super(message);
+        this.name = "AuthenticationError";
+        this.code = "AUTHENTICATION_ERROR";
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+// Utility function to combine multiple SDKs
+function combineSdks(sdks) {
+    return { ...sdks };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Complete Zapier SDK - combines all Zapier SDK packages",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,8 +18,10 @@
     "access": "restricted"
   },
   "dependencies": {
-    "@zapier/actions-sdk": "0.0.1",
-    "@zapier/shared-sdk": "0.0.1"
+    "dotenv": "^17.0.0",
+    "esbuild": "^0.25.5",
+    "find-up": "^7.0.0",
+    "zod": "^3.25.67"
   },
   "devDependencies": {
     "@types/node": "^24.0.1",

package/src/actions-sdk.ts

@@ -0,0 +1,356 @@
+import {
+  Integration,
+  Action,
+  ActionExecutionOptions,
+  ActionExecutionResult,
+  ActionField,
+  Authentication,
+  BaseSdkOptions,
+} from "./types";
+import { createZapierApi, type ApiClient } from "./api";
+import { listAuths } from "./functions/listAuths";
+import { listApps } from "./functions/listApps";
+import { getApp } from "./functions/getApp";
+import { listActions } from "./functions/listActions";
+import { getAction } from "./functions/getAction";
+import { runAction } from "./functions/runAction";
+import { listFields } from "./functions/listFields";
+import { generateTypes as generateTypesFunction } from "./functions/generateTypes";
+import { bundleCode as bundleCodeFunction } from "./functions/bundleCode";
+import {
+  AppsListOptions,
+  AppsGetOptions,
+  ActionsListOptions,
+  ActionsGetOptions,
+  ActionsRunOptions,
+  AuthsListOptions,
+  AuthsFindOptions,
+  FieldsListOptions,
+  GenerateOptions,
+  BundleOptions,
+} from "./schemas";
+export * from "./schemas";
+export * from "./output-schemas";
+
+export interface ActionsSdk {
+  // Resource namespaces
+  apps: AppsService;
+  actions: ActionsService;
+  auths: AuthsService;
+  fields: FieldsService;
+
+  // Root namespace tools
+  generate: GenerateFunction;
+  bundle: BundleFunction;
+}
+
+export interface AppsService {
+  list(options?: AppsListOptions): Promise<Integration[]>;
+  get(options: AppsGetOptions): Promise<Integration>;
+}
+
+interface ActionRunner {
+  (params: ActionsRunOptions): Promise<ActionExecutionResult>;
+}
+
+interface ActionProxy {
+  [app: string]: {
+    [type: string]: {
+      [action: string]: (
+        options?: ActionExecutionOptions,
+      ) => Promise<ActionExecutionResult>;
+    };
+  };
+}
+
+export interface GenerateFunction {
+  (options: GenerateOptions): Promise<string>;
+}
+
+export interface BundleFunction {
+  (options: BundleOptions): Promise<string>;
+}
+
+export interface ActionsService {
+  list(options?: ActionsListOptions): Promise<Action[]>;
+  get(options: ActionsGetOptions): Promise<Action>;
+  run: ActionRunner & ActionProxy;
+}
+
+export interface AuthsService {
+  list(options?: AuthsListOptions): Promise<Authentication[]>;
+  find(options: AuthsFindOptions): number;
+}
+
+export interface FieldsService {
+  list(options: FieldsListOptions): Promise<ActionField[]>;
+}
+
+export interface ActionsSdkOptions extends BaseSdkOptions {}
+
+export function createActionsSdk(options: ActionsSdkOptions = {}): ActionsSdk {
+  // 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,
+    authentications = {},
+    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 = createZapierApi({
+    baseUrl,
+    token: finalToken,
+    debug,
+    fetch: customFetch,
+  });
+
+  // Create SDK object - we'll populate services after creation to avoid circular dependency
+  const sdk: ActionsSdk = {} as ActionsSdk;
+
+  const appsService = createAppsService({
+    api,
+    token: finalToken,
+    authentications,
+    sdk,
+  });
+
+  const actionsService = createActionsService({
+    api,
+    token: finalToken,
+    authentications,
+    sdk,
+  });
+
+  const authsService = createAuthsService({
+    api,
+    token: finalToken,
+    authentications,
+    sdk,
+  });
+
+  const fieldsService = createFieldsService({
+    api,
+    token: finalToken,
+    authentications,
+    sdk,
+  });
+
+  // Create root namespace tools
+  const generateFunction: GenerateFunction = async (
+    options: GenerateOptions,
+  ) => {
+    return generateTypesFunction({ ...options, api, token: finalToken });
+  };
+
+  const bundleFunction: BundleFunction = async (options: BundleOptions) => {
+    return bundleCodeFunction(options);
+  };
+
+  // Populate the SDK object
+  sdk.apps = appsService;
+  sdk.actions = actionsService;
+  sdk.auths = authsService;
+  sdk.fields = fieldsService;
+  sdk.generate = generateFunction;
+  sdk.bundle = bundleFunction;
+
+  // Note: Debug logging for SDK initialization is now handled by the API client
+
+  return sdk;
+}
+
+interface AppsServiceOptions {
+  api: ApiClient;
+  token?: string;
+  authentications?: { [appKey: string]: { id: number }[] };
+  sdk: ActionsSdk;
+}
+
+interface AuthsServiceOptions {
+  api: ApiClient;
+  token?: string;
+  authentications?: { [appKey: string]: { id: number }[] };
+  sdk: ActionsSdk;
+}
+
+interface ActionsServiceOptions {
+  api: ApiClient;
+  token?: string;
+  authentications?: { [appKey: string]: { id: number }[] };
+  sdk: ActionsSdk;
+}
+
+interface FieldsServiceOptions {
+  api: ApiClient;
+  token?: string;
+  authentications?: { [appKey: string]: { id: number }[] };
+  sdk: ActionsSdk;
+}
+
+function createAppsService(options: AppsServiceOptions): AppsService {
+  const { api, token } = options;
+
+  return {
+    async list(options?: AppsListOptions): Promise<Integration[]> {
+      return listApps({ ...options, api, token });
+    },
+
+    async get(options: AppsGetOptions): Promise<Integration> {
+      return getApp({ ...options, api, token });
+    },
+  };
+}
+
+function createAuthsService(options: AuthsServiceOptions): AuthsService {
+  const { api, token, authentications } = options;
+
+  return {
+    async list(options?: AuthsListOptions): Promise<Authentication[]> {
+      return listAuths({ ...options, api, token });
+    },
+
+    find(options: { appKey: string }): number {
+      if (!authentications) {
+        throw new Error(`No authentication configured`);
+      }
+
+      const auths = authentications[options.appKey] || [];
+
+      if (auths.length === 0) {
+        throw new Error(
+          `No authentication configured for app "${options.appKey}"`,
+        );
+      }
+
+      if (auths.length > 1) {
+        throw new Error(
+          `Multiple authentications found for app "${options.appKey}". Please specify which one to use.`,
+        );
+      }
+
+      return auths[0].id;
+    },
+  };
+}
+
+function createFieldsService(options: FieldsServiceOptions): FieldsService {
+  const { api, token } = options;
+
+  return {
+    async list(options: FieldsListOptions): Promise<ActionField[]> {
+      return listFields({ ...options, api, token });
+    },
+  };
+}
+
+function createActionsService(options: ActionsServiceOptions): ActionsService {
+  const { api, token, authentications } = options;
+
+  // Create the base service with named methods
+  const baseService: ActionsService = {
+    async list(options?: ActionsListOptions): Promise<Action[]> {
+      return listActions({ ...options, api, token });
+    },
+
+    async get(options: ActionsGetOptions): Promise<Action> {
+      return getAction({ ...options, api, token });
+    },
+
+    // run will be replaced with function/proxy pattern below
+  } as ActionsService;
+
+  // Create the run function with proxy capabilities
+  const runFunction = async (
+    params: ActionsRunOptions,
+  ): Promise<ActionExecutionResult> => {
+    const { app, type, action, inputs, authId: providedAuthId } = params;
+
+    // Resolve auth ID for this specific app
+    let authId: number | undefined = providedAuthId;
+
+    if (!authId && authentications) {
+      const auths = authentications[app] || [];
+      if (auths.length === 0) {
+        throw new Error(`No authentication configured for app "${app}"`);
+      }
+      if (auths.length > 1) {
+        throw new Error(
+          `Multiple authentications found for app "${app}". Please specify which one to use.`,
+        );
+      }
+      authId = auths[0].id;
+    }
+
+    // Delegate to standalone runAction function
+    return runAction({
+      app,
+      type,
+      action,
+      inputs,
+      authId,
+      api,
+      token,
+    });
+  };
+
+  // Create proxy wrapper for the run function
+  const runWithProxy = new Proxy(runFunction, {
+    get(target, prop: string) {
+      if (typeof prop === "string") {
+        // Return app-level proxy
+        return new Proxy(
+          {},
+          {
+            get(_target, actionType: string) {
+              if (typeof actionType !== "string") return undefined;
+
+              return new Proxy(
+                {},
+                {
+                  get(_target, actionKey: string) {
+                    if (typeof actionKey !== "string") return undefined;
+
+                    // Return function that calls the main run function
+                    return async (
+                      options: ActionExecutionOptions = {},
+                    ): Promise<ActionExecutionResult> => {
+                      return await runFunction({
+                        app: prop,
+                        type: actionType as any, // Cast because proxy string can't be typed as enum
+                        action: actionKey,
+                        inputs: options.inputs,
+                        authId: options.authId,
+                      });
+                    };
+                  },
+                },
+              );
+            },
+          },
+        );
+      }
+      return target[prop];
+    },
+  });
+
+  // Add the run function/proxy to the base service
+  baseService.run = runWithProxy as ActionRunner & ActionProxy;
+
+  // Return the service with the new run function/proxy
+  return baseService;
+}