@zapier/zapier-sdk-cli 0.13.0 → 0.13.2

package/dist/src/plugins/add/ast-generator.js

@@ -1,4 +1,5 @@
 import * as ts from "typescript";
+import { toSnakeCase } from "@zapier/zapier-sdk";
 /**
  * AST-based TypeScript type generator using the TypeScript Compiler API
  */
@@ -15,24 +16,19 @@ export class AstTypeGenerator {
      * Generate TypeScript types using AST for a specific app
      */
     async generateTypes(options) {
-        const { appKey, authenticationId, sdk } = options;
-        // Parse app identifier (support app@version format)
-        const { app, version } = this.parseAppIdentifier(appKey);
-        // Fetch all actions for the app
+        const { app, authenticationId, sdk } = options;
+        // 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 = [];
         if (authenticationId) {
             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,
@@ -61,7 +57,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 || "write",
                     title: action.title || action.key,
                     type: "action",
@@ -70,24 +66,17 @@ 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);
     }
-    parseAppIdentifier(identifier) {
-        const parts = identifier.split("@");
-        return {
-            app: parts[0],
-            version: parts[1],
-        };
-    }
-    createSourceFile(appKey, actions, version) {
-        const appName = this.capitalize(appKey);
-        const versionComment = version
-            ? ` * Generated for ${appKey}@${version}`
-            : ` * Generated for ${appKey}`;
+    createSourceFile(app, actions) {
+        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()}
 
@@ -99,11 +88,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 = [
             // Import the SDK to activate module augmentation
             this.createImportStatement(["@zapier/zapier-sdk"]),
@@ -138,7 +127,8 @@ Usage:
         const appWithFactoryType = this.createAppWithFactoryType(appName);
         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
         statements.push(this.factory.createExportDeclaration(undefined, false, this.factory.createNamedExports([])));
@@ -280,13 +270,13 @@ Usage:
             this.factory.createTypeReferenceNode(`${appName}AppProxy`),
         ]));
     }
-    createModuleAugmentation(appKey, appName) {
+    createModuleAugmentation(appKeys, appName) {
         // 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"), this.factory.createModuleBlock([
-            this.factory.createInterfaceDeclaration(undefined, "ZapierSdkApps", undefined, undefined, [
-                this.factory.createPropertySignature(undefined, appKey, undefined, this.factory.createTypeReferenceNode(`${appName}AppWithFactory`)),
-            ]),
+            this.factory.createInterfaceDeclaration(undefined, "ZapierSdkApps", undefined, undefined, properties),
         ]));
     }
     mapFieldTypeToTypeNode(field) {
@@ -324,40 +314,6 @@ Usage:
                 ]);
         }
     }
-    generateEmptyTypesFile(appKey, version) {
-        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
-  }
-}
-`;
-    }
     capitalize(str) {
         return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
     }
@@ -383,4 +339,64 @@ declare module "@zapier/zapier-sdk" {
         // Escape comment text to prevent breaking the JSDoc comment
         return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
     }
+    createPropertyName(name) {
+        // 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);
+        }
+    }
+    isValidIdentifier(name) {
+        // JavaScript identifier rules: must start with letter, $, or _,
+        // followed by letters, digits, $, or _
+        return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+    }
+    getPreferredProgrammaticKey(app) {
+        // 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);
+    }
+    getPreferredAppName(app) {
+        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);
+    }
+    sanitizeToIdentifier(name) {
+        // 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;
+    }
+    getAllKeys(app) {
+        // 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/dist/src/plugins/add/index.js

@@ -87,7 +87,7 @@ export const addPlugin = ({ sdk, context }) => {
                     // Use AST-based generator directly
                     const generator = new AstTypeGenerator();
                     const typeDefinitions = await generator.generateTypes({
-                        appKey: manifestKey,
+                        app,
                         authenticationId,
                         sdk,
                     });