@zapier/zapier-sdk-cli 0.13.10 → 0.13.12

package/src/generators/ast-generator.ts

@@ -8,7 +8,7 @@ import type {
   ManifestPluginProvides,
   AppItem,
 } from "@zapier/zapier-sdk";
-import { toSnakeCase } from "@zapier/zapier-sdk";
+import { toSnakeCase, batch } from "@zapier/zapier-sdk";
 
 interface ActionWithInputFields extends Omit<Action, "inputFields" | "type"> {
   inputFields: InputFieldItem[];
@@ -58,53 +58,61 @@ export class AstTypeGenerator {
     // Fetch input fields for each action
     const actionsWithFields: ActionWithInputFields[] = [];
 
-    if (authenticationId) {
-      for (const action of actions) {
-        try {
-          const fieldsResult = await sdk.listInputFields({
-            appKey: app.implementation_id,
-            actionKey: action.key,
-            actionType: action.action_type,
-            authenticationId: authenticationId,
-          });
-
-          const fields = fieldsResult.data as InputFieldItem[];
-          actionsWithFields.push({
-            ...action,
-            inputFields: fields,
-            name: action.title || action.key,
-          });
-        } catch {
-          // If we can't get fields for an action, include it without fields
-          actionsWithFields.push({
-            ...action,
-            inputFields: [],
-            name: action.title || action.key,
-          });
-        }
+    // Fetch all input fields with concurrency limiting for better reliability
+    // Using batch() instead of Promise.allSettled() prevents overwhelming the API
+    // and triggering rate limits when apps have many actions
+    const inputFieldsTasks = actions.map(
+      (action) => () =>
+        sdk.listInputFields({
+          appKey: app.implementation_id,
+          actionKey: action.key,
+          actionType: action.action_type,
+          authenticationId: authenticationId,
+        }),
+    );
+
+    const results = await batch(inputFieldsTasks, {
+      concurrency: 50, // Limit to 50 concurrent requests
+      retry: true, // Automatically retry transient failures
+      timeoutMs: 180_000, // 3 minute overall timeout
+      taskTimeoutMs: 30_000, // 30 seconds per-task timeout (API calls shouldn't take longer)
+    });
+
+    const failedActions: string[] = [];
+
+    results.forEach((result, i) => {
+      const action = actions[i];
+
+      if (result.status === "fulfilled") {
+        actionsWithFields.push({
+          ...action,
+          inputFields: result.value.data as InputFieldItem[],
+          name: action.title || action.key,
+        });
+      } else {
+        failedActions.push(
+          `${action.key} (${action.action_type}): ${result.reason?.message || "Unknown error"}`,
+        );
+        actionsWithFields.push({
+          ...action,
+          inputFields: [],
+          name: action.title || action.key,
+          app_key: action.app_key || app.implementation_id,
+          action_type: (action.action_type as Action["type"]) || "write",
+          title: action.title || action.key,
+          type: "action" as const,
+          description: action.description || "",
+        });
       }
-    } else {
-      // Convert actions to have empty input fields (will generate generic types)
-      actions.forEach(
-        (action: {
-          key: string;
-          title?: string;
-          app_key?: string;
-          action_type?: string;
-          description?: string;
-        }) => {
-          actionsWithFields.push({
-            ...action,
-            inputFields: [],
-            name: action.title || action.key,
-            app_key: action.app_key || app.implementation_id,
-            action_type: (action.action_type as Action["type"]) || "write",
-            title: action.title || action.key,
-            type: "action" as const,
-            description: action.description || "",
-          });
-        },
+    });
+
+    if (failedActions.length > 0) {
+      console.warn(
+        `Failed to fetch input fields for ${failedActions.length} action(s):`,
       );
+      failedActions.forEach((failedAction) => {
+        console.warn(`  - ${failedAction}`);
+      });
     }
 
     // Generate TypeScript AST nodes

package/src/plugins/login/index.ts

@@ -29,22 +29,36 @@ interface LoginPluginProvides {
 const CLI_COMMAND_EXECUTED_EVENT_SUBJECT =
   "platform.sdk.CliCommandExecutedEvent";
 
-const loginWithSdk = createFunction(async function loginWithSdk(
-  options: LoginOptions,
-): Promise<void> {
-  const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : 300;
-  if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
-    throw new Error("Timeout must be a positive number");
-  }
+// Internal type for loginWithSdk that includes SDK URL options
+interface LoginWithSdkOptions extends LoginOptions {
+  baseUrl?: string;
+  authBaseUrl?: string;
+  authClientId?: string;
+}
+
+const loginWithSdk = createFunction(
+  async (options: LoginWithSdkOptions): Promise<void> => {
+    const timeoutSeconds = options.timeout
+      ? parseInt(options.timeout, 10)
+      : 300;
+    if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
+      throw new Error("Timeout must be a positive number");
+    }
 
-  await login(timeoutSeconds * 1000); // Convert to milliseconds
-  const user = await getLoggedInUser();
+    await login({
+      timeoutMs: timeoutSeconds * 1000,
+      baseUrl: options.baseUrl,
+      authBaseUrl: options.authBaseUrl,
+      authClientId: options.authClientId,
+    });
+    const user = await getLoggedInUser();
 
-  console.log(`✅ Successfully logged in as ${user.email}`);
+    console.log(`✅ Successfully logged in as ${user.email}`);
 
-  // Force immediate exit to prevent hanging (especially in development with tsx)
-  setTimeout(() => process.exit(0), 100);
-}, LoginSchema);
+    // Force immediate exit to prevent hanging (especially in development with tsx)
+    setTimeout(() => process.exit(0), 100);
+  },
+);
 
 export const loginPlugin: Plugin<
   {},
@@ -58,7 +72,12 @@ export const loginPlugin: Plugin<
     let errorMessage: string | null = null;
 
     try {
-      await loginWithSdk(options);
+      await loginWithSdk({
+        ...options,
+        baseUrl: context.options?.baseUrl,
+        authBaseUrl: context.options?.authBaseUrl,
+        authClientId: context.options?.authClientId,
+      });
       success = true;
     } catch (error) {
       success = false;

package/src/utils/auth/login.ts

@@ -6,16 +6,20 @@ import type { Socket } from "net";
 
 import {
   AUTH_MODE_HEADER,
-  LOGIN_CLIENT_ID,
+  ZAPIER_AUTH_CLIENT_ID,
   LOGIN_PORTS,
   LOGIN_TIMEOUT_MS,
-  ZAPIER_BASE,
 } from "../constants";
 import { spinPromise } from "../spinner";
 import log from "../log";
 import api from "../api/client";
 import getCallablePromise from "../getCallablePromise";
-import { updateLogin, logout } from "@zapier/zapier-sdk-cli-login";
+import {
+  updateLogin,
+  logout,
+  getAuthTokenUrl,
+  getAuthAuthorizeUrl,
+} from "@zapier/zapier-sdk-cli-login";
 
 const findAvailablePort = (): Promise<number> => {
   return new Promise((resolve, reject) => {
@@ -62,7 +66,22 @@ const generateRandomString = () => {
   ).join("");
 };
 
-const login = async (timeoutMs: number = LOGIN_TIMEOUT_MS): Promise<string> => {
+interface LoginOptions {
+  timeoutMs?: number;
+  baseUrl?: string;
+  authBaseUrl?: string;
+  authClientId?: string;
+}
+
+const login = async ({
+  timeoutMs = LOGIN_TIMEOUT_MS,
+  baseUrl,
+  authBaseUrl,
+  authClientId,
+}: LoginOptions): Promise<string> => {
+  const authOptions = { baseUrl, authBaseUrl };
+  const tokenUrl = getAuthTokenUrl(authOptions);
+  const authorizeUrl = getAuthAuthorizeUrl(authOptions);
   // Force logout
   logout();
 
@@ -106,9 +125,9 @@ const login = async (timeoutMs: number = LOGIN_TIMEOUT_MS): Promise<string> => {
   const { code_verifier: codeVerifier, code_challenge: codeChallenge } =
     await pkceChallenge();
 
-  const authUrl = `${ZAPIER_BASE}/oauth/authorize/?${new URLSearchParams({
+  const authUrl = `${authorizeUrl}?${new URLSearchParams({
     response_type: "code",
-    client_id: LOGIN_CLIENT_ID,
+    client_id: authClientId || ZAPIER_AUTH_CLIENT_ID,
     redirect_uri: redirectUri,
     scope: "internal offline_access",
     state: generateRandomString(),
@@ -165,12 +184,12 @@ const login = async (timeoutMs: number = LOGIN_TIMEOUT_MS): Promise<string> => {
     refresh_token: string;
     expires_in: number;
   }>(
-    `${ZAPIER_BASE}/oauth/token/`,
+    tokenUrl,
     {
       grant_type: "authorization_code",
       code: await promisedCode,
       redirect_uri: redirectUri,
-      client_id: LOGIN_CLIENT_ID,
+      client_id: authClientId || ZAPIER_AUTH_CLIENT_ID,
       code_verifier: codeVerifier,
     },
     {

package/src/utils/constants.ts

@@ -1,7 +1,6 @@
 // Import shared OAuth constants from login package
 export {
-  ZAPIER_BASE,
-  LOGIN_CLIENT_ID,
+  ZAPIER_AUTH_CLIENT_ID,
   AUTH_MODE_HEADER,
 } from "@zapier/zapier-sdk-cli-login";