@zapier/zapier-sdk-cli 0.13.1 → 0.13.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -42,9 +42,9 @@
     "ora": "^8.2.0",
     "pkce-challenge": "^5.0.0",
     "zod": "^3.25.67",
-    "@zapier/zapier-sdk": "0.13.1",
+    "@zapier/zapier-sdk": "0.13.3",
     "@zapier/zapier-sdk-cli-login": "0.3.2",
-    "@zapier/zapier-sdk-mcp": "0.3.14"
+    "@zapier/zapier-sdk-mcp": "0.3.16"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",

package/src/plugins/add/ast-generator.ts

@@ -6,7 +6,9 @@ import type {
   ListActionsPluginProvides,
   ListInputFieldsPluginProvides,
   ManifestPluginProvides,
+  AppItem,
 } from "@zapier/zapier-sdk";
+import { toSnakeCase } from "@zapier/zapier-sdk";
 
 interface ActionWithInputFields extends Omit<Action, "inputFields" | "type"> {
   inputFields: InputFieldItem[];
@@ -17,7 +19,7 @@ interface ActionWithInputFields extends Omit<Action, "inputFields" | "type"> {
 }
 
 interface GenerateTypesOptions {
-  appKey: string;
+  app: AppItem;
   authenticationId?: number;
 }
 
@@ -44,22 +46,15 @@ export class AstTypeGenerator {
       >;
     },
   ): Promise<string> {
-    const { appKey, authenticationId, sdk } = options;
+    const { app, authenticationId, sdk } = options;
 
-    // Parse app identifier (support app@version format)
-    const { app, version } = this.parseAppIdentifier(appKey);
-
-    // Fetch all actions for the app
+    // Fetch all actions for the app using implementation_id for correct versioning
     const actionsResult = await sdk.listActions({
-      appKey: app,
+      appKey: app.implementation_id,
     });
 
     const actions = actionsResult.data;
 
-    if (actions.length === 0) {
-      return this.generateEmptyTypesFile(app, version);
-    }
-
     // Fetch input fields for each action
     const actionsWithFields: ActionWithInputFields[] = [];
 
@@ -67,7 +62,7 @@ export class AstTypeGenerator {
       for (const action of actions) {
         try {
           const fieldsResult = await sdk.listInputFields({
-            appKey: appKey,
+            appKey: app.implementation_id,
             actionKey: action.key,
             actionType: action.action_type,
             authenticationId: authenticationId,
@@ -102,7 +97,7 @@ export class AstTypeGenerator {
             ...action,
             inputFields: [],
             name: action.title || action.key,
-            app_key: action.app_key || appKey,
+            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,
@@ -113,35 +108,23 @@ export class AstTypeGenerator {
     }
 
     // Generate TypeScript AST nodes
-    const sourceFile = this.createSourceFile(app, actionsWithFields, version);
+    const sourceFile = this.createSourceFile(app, actionsWithFields);
 
     // Print the AST to string
     return this.printer.printFile(sourceFile);
   }
 
-  private parseAppIdentifier(identifier: string): {
-    app: string;
-    version?: string;
-  } {
-    const parts = identifier.split("@");
-    return {
-      app: parts[0],
-      version: parts[1],
-    };
-  }
-
   private createSourceFile(
-    appKey: string,
+    app: AppItem,
     actions: ActionWithInputFields[],
-    version?: string,
   ): ts.SourceFile {
-    const appName = this.capitalize(appKey);
-    const versionComment = version
-      ? ` * Generated for ${appKey}@${version}`
-      : ` * Generated for ${appKey}`;
+    const appName = this.getPreferredAppName(app);
+    const versionComment = ` * Generated for ${app.implementation_id}`;
+    const preferredKey = this.getPreferredProgrammaticKey(app);
+    const myVariableName = `my${appName}`;
 
     // Create header comment
-    const headerComment = `Auto-generated TypeScript types for Zapier ${appKey} actions
+    const headerComment = `Auto-generated TypeScript types for Zapier ${app.key} actions
 ${versionComment.slice(3)}
 Generated on: ${new Date().toISOString()}
 
@@ -153,11 +136,11 @@ Usage:
   
   const zapier = createZapierSdk();
   // Types are automatically available:
-  await zapier.apps.${appKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
+  await zapier.apps.${preferredKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
   
   // Factory usage (pinned auth):
-  const my${appName} = zapier.apps.${appKey}({ authenticationId: 123 })
-  await my${appName}.search.user_by_email({ inputs: { email } })`;
+  const ${myVariableName} = zapier.apps.${preferredKey}({ authenticationId: 123 })
+  await ${myVariableName}.search.user_by_email({ inputs: { email } })`;
 
     const statements: ts.Statement[] = [
       // Import the SDK to activate module augmentation
@@ -211,7 +194,8 @@ Usage:
     statements.push(appWithFactoryType);
 
     // Generate module augmentation for automatic type integration
-    const moduleAugmentation = this.createModuleAugmentation(appKey, appName);
+    const allKeys = this.getAllKeys(app);
+    const moduleAugmentation = this.createModuleAugmentation(allKeys, appName);
     statements.push(moduleAugmentation);
 
     // Add empty export to make this a module
@@ -607,11 +591,21 @@ Usage:
   }
 
   private createModuleAugmentation(
-    appKey: string,
+    appKeys: string[],
     appName: string,
   ): ts.ModuleDeclaration {
     // Create: declare module "@zapier/zapier-sdk" { interface ZapierSdkApps { [appKey]: AppWithFactory } }
     // This creates a new interface that we can merge with ZapierSdk
+    // Create properties for all keys (main key + other_keys)
+    const properties = appKeys.map((appKey) =>
+      this.factory.createPropertySignature(
+        undefined,
+        this.createPropertyName(appKey),
+        undefined,
+        this.factory.createTypeReferenceNode(`${appName}AppWithFactory`),
+      ),
+    );
+
     return this.factory.createModuleDeclaration(
       [this.factory.createToken(ts.SyntaxKind.DeclareKeyword)],
       this.factory.createStringLiteral("@zapier/zapier-sdk"),
@@ -621,14 +615,7 @@ Usage:
           "ZapierSdkApps",
           undefined,
           undefined,
-          [
-            this.factory.createPropertySignature(
-              undefined,
-              appKey,
-              undefined,
-              this.factory.createTypeReferenceNode(`${appName}AppWithFactory`),
-            ),
-          ],
+          properties,
         ),
       ]),
     );
@@ -673,42 +660,6 @@ Usage:
     }
   }
 
-  private generateEmptyTypesFile(appKey: string, version?: string): string {
-    const appName = this.capitalize(appKey);
-    const versionComment = version
-      ? ` * Generated for ${appKey}@${version}`
-      : ` * Generated for ${appKey}`;
-
-    return `/* eslint-disable @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${new Date().toISOString()}
- * 
- * No actions found for this app.
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult, ZapierFetchInitOptions } from '@zapier/zapier-sdk'
-
-interface ${appName}AppProxy {
-  /** Make authenticated HTTP requests through Zapier's Relay service */
-  fetch: (url: string | URL, init?: ZapierFetchInitOptions) => Promise<Response>
-}
-
-interface ${appName}AppFactory {
-  (options: { authenticationId: number }): ${appName}AppProxy
-}
-
-type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
-
-declare module "@zapier/zapier-sdk" {
-  interface ZapierSdkApps {
-    ${appKey}: ${appName}AppWithFactory
-  }
-}
-`;
-  }
-
   private capitalize(str: string): string {
     return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
   }
@@ -741,4 +692,75 @@ declare module "@zapier/zapier-sdk" {
     // Escape comment text to prevent breaking the JSDoc comment
     return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
   }
+
+  private createPropertyName(name: string): ts.PropertyName {
+    // Check if the name is a valid JavaScript identifier
+    if (this.isValidIdentifier(name)) {
+      return this.factory.createIdentifier(name);
+    } else {
+      // Use string literal for invalid identifiers (e.g., contains dashes)
+      return this.factory.createStringLiteral(name);
+    }
+  }
+
+  private isValidIdentifier(name: string): boolean {
+    // JavaScript identifier rules: must start with letter, $, or _,
+    // followed by letters, digits, $, or _
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+  }
+
+  private getPreferredProgrammaticKey(app: AppItem): string {
+    // If we have a slug, convert it to snake_case as the preferred programmatic key
+    if (app.slug) {
+      const snakeCaseSlug = toSnakeCase(app.slug);
+      if (this.isValidIdentifier(snakeCaseSlug)) {
+        return snakeCaseSlug;
+      }
+    }
+
+    // Otherwise, use the main key if it's a valid identifier
+    if (this.isValidIdentifier(app.key)) {
+      return app.key;
+    }
+
+    // Fallback: sanitize the key to make it a valid identifier
+    return this.sanitizeToIdentifier(app.key);
+  }
+
+  private getPreferredAppName(app: AppItem): string {
+    const preferredKey = this.getPreferredProgrammaticKey(app);
+
+    // If it's snake_case, convert to PascalCase
+    if (preferredKey.includes("_")) {
+      return preferredKey
+        .split("_")
+        .map((word) => this.capitalize(word.toLowerCase()))
+        .join("");
+    }
+
+    // Otherwise, capitalize first letter for PascalCase
+    return this.capitalize(preferredKey);
+  }
+
+  private sanitizeToIdentifier(name: string): string {
+    // Convert any string to a valid JavaScript identifier
+    let sanitized = name.replace(/[^a-zA-Z0-9_$]/g, "_");
+
+    // If it starts with a number, prepend an underscore
+    if (/^[0-9]/.test(sanitized)) {
+      sanitized = "_" + sanitized;
+    }
+
+    return sanitized;
+  }
+
+  private getAllKeys(app: AppItem): string[] {
+    // Return all possible keys for this app
+    const allKeys = new Set([app.key]);
+    if (app.slug) {
+      allKeys.add(app.slug);
+      allKeys.add(toSnakeCase(app.slug));
+    }
+    return Array.from(allKeys);
+  }
 }

package/src/plugins/add/index.ts

@@ -7,6 +7,7 @@ import type {
   ListInputFieldsPluginProvides,
   ListAuthenticationsPluginProvides,
   ManifestPluginProvides,
+  AppItem,
 } from "@zapier/zapier-sdk";
 import { createFunction } from "@zapier/zapier-sdk";
 import { AddSchema, type AddOptions } from "./schemas";
@@ -72,7 +73,7 @@ export const addPlugin: Plugin<
     // Get apps using listApps (which respects existing manifest for version locking)
     console.log(`📦 Looking up ${appKeys.length} app(s)...`);
     const appsIterator = sdk.listApps({ appKeys }).items();
-    const apps = [];
+    const apps: AppItem[] = [];
     for await (const app of appsIterator) {
       apps.push(app);
     }
@@ -151,7 +152,7 @@ export const addPlugin: Plugin<
           // Use AST-based generator directly
           const generator = new AstTypeGenerator();
           const typeDefinitions = await generator.generateTypes({
-            appKey: manifestKey,
+            app,
             authenticationId,
             sdk,
           });

package/src/utils/schema-formatter.ts

@@ -66,13 +66,22 @@ function formatSingleItem(formatted: FormattedItem, itemNumber: number): void {
   // Build the main title line with optional subtitle
   let titleLine = `${chalk.gray(`${itemNumber + 1}.`)} ${chalk.cyan(formatted.title)}`;
 
-  // Generate subtitle from id or key
-  if (formatted.id) {
-    titleLine += ` ${chalk.gray(`(ID: ${formatted.id})`)}`;
-  } else if (formatted.keys) {
-    titleLine += ` ${chalk.gray(`(${formatted.keys.join(", ")})`)}`;
+  // Generate subtitle - always show key if available, then ID if available
+  const subtitleParts = [];
+  if (formatted.keys) {
+    subtitleParts.push(...formatted.keys);
   } else if (formatted.key) {
-    titleLine += ` ${chalk.gray(`(${formatted.key})`)}`;
+    subtitleParts.push(formatted.key);
+  }
+  if (formatted.id) {
+    subtitleParts.push(formatted.id);
+  }
+
+  // Remove duplicates while preserving order
+  const uniqueParts = [...new Set(subtitleParts)];
+
+  if (uniqueParts.length > 0) {
+    titleLine += ` ${chalk.gray(`(${uniqueParts.join(", ")})`)}`;
   }
   console.log(titleLine);