@zapier/zapier-sdk-cli 0.16.1 → 0.16.3

package/src/generators/ast-generator.ts

@@ -1,774 +0,0 @@
-import * as ts from "typescript";
-import type {
-  Action,
-  InputFieldItem,
-  GetSdkType,
-  ListActionsPluginProvides,
-  ListInputFieldsPluginProvides,
-  ManifestPluginProvides,
-  AppItem,
-} from "@zapier/zapier-sdk";
-import { toSnakeCase, batch } from "@zapier/zapier-sdk";
-
-interface ActionWithInputFields extends Omit<Action, "inputFields" | "type"> {
-  inputFields: InputFieldItem[];
-  app_key: string;
-  action_type: Action["type"];
-  title: string;
-  type: "action";
-}
-
-interface GenerateTypesOptions {
-  app: AppItem;
-  authenticationId?: number;
-}
-
-/**
- * AST-based TypeScript type generator using the TypeScript Compiler API
- */
-export class AstTypeGenerator {
-  private readonly factory = ts.factory;
-  private readonly printer = ts.createPrinter({
-    newLine: ts.NewLineKind.LineFeed,
-    removeComments: false,
-    omitTrailingSemicolon: false,
-  });
-
-  /**
-   * Generate TypeScript types using AST for a specific app
-   */
-  async generateTypes(
-    options: GenerateTypesOptions & {
-      sdk: GetSdkType<
-        ListActionsPluginProvides &
-          ListInputFieldsPluginProvides &
-          ManifestPluginProvides
-      >;
-    },
-  ): Promise<string> {
-    const { app, authenticationId, sdk } = options;
-
-    // Fetch all actions for the app using implementation_id for correct versioning
-    const actionsResult = await sdk.listActions({
-      appKey: app.implementation_id,
-    });
-
-    const actions = actionsResult.data;
-
-    // Fetch input fields for each action
-    const actionsWithFields: ActionWithInputFields[] = [];
-
-    // 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 || "",
-        });
-      }
-    });
-
-    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
-    const sourceFile = this.createSourceFile(app, actionsWithFields);
-
-    // Print the AST to string
-    return this.printer.printFile(sourceFile);
-  }
-
-  private createSourceFile(
-    app: AppItem,
-    actions: ActionWithInputFields[],
-  ): ts.SourceFile {
-    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 ${app.key} actions
-${versionComment.slice(3)}
-Generated on: ${new Date().toISOString()}
-
-This file automatically augments the base SDK types when present.
-No manual imports or type casting required.
-
-Usage:
-  import { createZapierSdk } from "@zapier/zapier-sdk";
-  
-  const zapier = createZapierSdk();
-  // Types are automatically available:
-  await zapier.apps.${preferredKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
-  
-  // Factory usage (pinned auth):
-  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
-      this.createImportStatement(["@zapier/zapier-sdk"]),
-
-      // Import types we'll use
-      this.createTypeImportStatement(
-        [
-          "ActionExecutionOptions",
-          "ActionExecutionResult",
-          "ZapierFetchInitOptions",
-        ],
-        "@zapier/zapier-sdk",
-      ),
-    ];
-
-    // Group actions by type
-    const actionsByType = this.groupActionsByType(actions);
-
-    // Generate input interfaces for each action
-    actions.forEach((action) => {
-      if (action.inputFields.length > 0) {
-        const inputInterface = this.createInputInterface(appName, action);
-        statements.push(inputInterface);
-      }
-    });
-
-    // Generate action type interfaces
-    Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
-      const actionInterface = this.createActionInterface(
-        appName,
-        actionType,
-        typeActions,
-      );
-      statements.push(actionInterface);
-    });
-
-    // Generate app proxy interface
-    const appProxyInterface = this.createAppProxyInterface(
-      appName,
-      actionsByType,
-    );
-    statements.push(appProxyInterface);
-
-    // Generate app factory interface
-    const appFactoryInterface = this.createAppFactoryInterface(appName);
-    statements.push(appFactoryInterface);
-
-    // Generate combined app type
-    const appWithFactoryType = this.createAppWithFactoryType(appName);
-    statements.push(appWithFactoryType);
-
-    // Generate module augmentation for automatic type integration
-    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([]),
-      ),
-    );
-
-    // Create source file
-    const sourceFile = ts.createSourceFile(
-      "generated.d.ts",
-      "",
-      ts.ScriptTarget.Latest,
-      false,
-      ts.ScriptKind.TS,
-    );
-
-    // Add the header comment and ESLint disable as leading trivia to the first statement
-    if (statements.length > 0) {
-      // Add ESLint disable comment
-      ts.addSyntheticLeadingComment(
-        statements[0],
-        ts.SyntaxKind.MultiLineCommentTrivia,
-        " eslint-disable @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any ",
-        true,
-      );
-      // Add header comment
-      ts.addSyntheticLeadingComment(
-        statements[0],
-        ts.SyntaxKind.MultiLineCommentTrivia,
-        headerComment,
-        true,
-      );
-    }
-
-    return this.factory.updateSourceFile(sourceFile, statements);
-  }
-
-  private createImportStatement(
-    imports: string[],
-    from?: string,
-  ): ts.ImportDeclaration {
-    // Handle side-effect only import (no imports, just the module path)
-    if (imports.length === 1 && !from && imports[0].startsWith("@")) {
-      return this.factory.createImportDeclaration(
-        undefined,
-        undefined,
-        this.factory.createStringLiteral(imports[0]),
-        undefined,
-      );
-    }
-
-    const fromModule = from || imports[0];
-    const importNames = from ? imports : [];
-
-    return this.factory.createImportDeclaration(
-      undefined,
-      importNames.length > 0
-        ? this.factory.createImportClause(
-            false,
-            undefined,
-            this.factory.createNamedImports(
-              importNames.map((name) =>
-                this.factory.createImportSpecifier(
-                  false,
-                  undefined,
-                  this.factory.createIdentifier(name),
-                ),
-              ),
-            ),
-          )
-        : undefined,
-      this.factory.createStringLiteral(fromModule),
-      undefined,
-    );
-  }
-
-  private createTypeImportStatement(
-    imports: string[],
-    from: string,
-  ): ts.ImportDeclaration {
-    return this.factory.createImportDeclaration(
-      undefined,
-      this.factory.createImportClause(
-        true, // typeOnly: true
-        undefined,
-        this.factory.createNamedImports(
-          imports.map((name) =>
-            this.factory.createImportSpecifier(
-              false,
-              undefined,
-              this.factory.createIdentifier(name),
-            ),
-          ),
-        ),
-      ),
-      this.factory.createStringLiteral(from),
-      undefined,
-    );
-  }
-
-  private groupActionsByType(
-    actions: ActionWithInputFields[],
-  ): Record<string, ActionWithInputFields[]> {
-    return actions.reduce(
-      (acc: Record<string, ActionWithInputFields[]>, action) => {
-        if (!acc[action.action_type]) {
-          acc[action.action_type] = [];
-        }
-        acc[action.action_type].push(action);
-        return acc;
-      },
-      {} as Record<string, ActionWithInputFields[]>,
-    );
-  }
-
-  private createInputInterface(
-    appName: string,
-    action: ActionWithInputFields,
-  ): ts.InterfaceDeclaration {
-    const inputTypeName = `${appName}${this.capitalize(action.action_type)}${this.capitalize(
-      this.sanitizeActionName(action.key),
-    )}Inputs`;
-
-    const properties = action.inputFields.map((field: InputFieldItem) => {
-      const fieldType = this.mapFieldTypeToTypeNode(field);
-      const isOptional = !field.is_required;
-
-      let property = this.factory.createPropertySignature(
-        undefined,
-        this.sanitizeFieldName(field.key),
-        isOptional
-          ? this.factory.createToken(ts.SyntaxKind.QuestionToken)
-          : undefined,
-        fieldType,
-      );
-
-      // Add JSDoc comment if description exists
-      if (field.description) {
-        property = ts.addSyntheticLeadingComment(
-          property,
-          ts.SyntaxKind.MultiLineCommentTrivia,
-          `* ${this.escapeComment(field.description)} `,
-          true,
-        );
-      }
-
-      return property;
-    });
-
-    return this.factory.createInterfaceDeclaration(
-      undefined,
-      inputTypeName,
-      undefined,
-      undefined,
-      properties,
-    );
-  }
-
-  private createActionInterface(
-    appName: string,
-    actionType: string,
-    typeActions: ActionWithInputFields[],
-  ): ts.InterfaceDeclaration {
-    const typeName = `${appName}${this.capitalize(actionType)}Actions`;
-
-    const methods = typeActions.map((action) => {
-      const actionName = this.sanitizeActionName(action.key);
-
-      let methodSignature: ts.MethodSignature;
-
-      if (action.inputFields.length > 0) {
-        // Generate type-safe action method signature
-        const inputTypeName = `${appName}${this.capitalize(action.action_type)}${this.capitalize(
-          this.sanitizeActionName(action.key),
-        )}Inputs`;
-
-        const inputsType = this.factory.createTypeLiteralNode([
-          this.factory.createPropertySignature(
-            undefined,
-            "inputs",
-            undefined,
-            this.factory.createTypeReferenceNode(inputTypeName),
-          ),
-        ]);
-
-        const omitType = this.factory.createTypeReferenceNode("Omit", [
-          this.factory.createTypeReferenceNode("ActionExecutionOptions"),
-          this.factory.createLiteralTypeNode(
-            this.factory.createStringLiteral("inputs"),
-          ),
-        ]);
-
-        const optionsType = this.factory.createIntersectionTypeNode([
-          inputsType,
-          omitType,
-        ]);
-
-        methodSignature = this.factory.createMethodSignature(
-          undefined,
-          actionName,
-          undefined,
-          undefined,
-          [
-            this.factory.createParameterDeclaration(
-              undefined,
-              undefined,
-              "options",
-              undefined,
-              optionsType,
-            ),
-          ],
-          this.factory.createTypeReferenceNode("Promise", [
-            this.factory.createTypeReferenceNode("ActionExecutionResult"),
-          ]),
-        );
-      } else {
-        // No specific input fields available - use generic Record<string, any> for inputs
-        const genericInputsType = this.factory.createTypeLiteralNode([
-          this.factory.createPropertySignature(
-            undefined,
-            "inputs",
-            this.factory.createToken(ts.SyntaxKind.QuestionToken),
-            this.factory.createTypeReferenceNode("Record", [
-              this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-              this.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-            ]),
-          ),
-        ]);
-
-        const intersectionType = this.factory.createIntersectionTypeNode([
-          genericInputsType,
-          this.factory.createTypeReferenceNode("ActionExecutionOptions"),
-        ]);
-
-        methodSignature = this.factory.createMethodSignature(
-          undefined,
-          actionName,
-          undefined,
-          undefined,
-          [
-            this.factory.createParameterDeclaration(
-              undefined,
-              undefined,
-              "options",
-              this.factory.createToken(ts.SyntaxKind.QuestionToken),
-              intersectionType,
-            ),
-          ],
-          this.factory.createTypeReferenceNode("Promise", [
-            this.factory.createTypeReferenceNode("ActionExecutionResult"),
-          ]),
-        );
-      }
-
-      // Add JSDoc comment if description exists
-      if (action.description) {
-        methodSignature = ts.addSyntheticLeadingComment(
-          methodSignature,
-          ts.SyntaxKind.MultiLineCommentTrivia,
-          `* ${this.escapeComment(action.description)} `,
-          true,
-        );
-      }
-
-      return methodSignature;
-    });
-
-    return this.factory.createInterfaceDeclaration(
-      undefined,
-      typeName,
-      undefined,
-      undefined,
-      methods,
-    );
-  }
-
-  private createAppProxyInterface(
-    appName: string,
-    actionsByType: Record<string, ActionWithInputFields[]>,
-  ): ts.InterfaceDeclaration {
-    const properties = [
-      ...Object.keys(actionsByType).map((actionType) =>
-        this.factory.createPropertySignature(
-          undefined,
-          actionType,
-          undefined,
-          this.factory.createTypeReferenceNode(
-            `${appName}${this.capitalize(actionType)}Actions`,
-          ),
-        ),
-      ),
-      // Always include fetch method for authenticated HTTP requests
-      this.createFetchMethodProperty(),
-    ];
-
-    return this.factory.createInterfaceDeclaration(
-      undefined,
-      `${appName}AppProxy`,
-      undefined,
-      undefined,
-      properties,
-    );
-  }
-
-  private createFetchMethodProperty(): ts.PropertySignature {
-    let property = this.factory.createPropertySignature(
-      undefined,
-      "fetch",
-      undefined,
-      this.factory.createFunctionTypeNode(
-        undefined,
-        [
-          this.factory.createParameterDeclaration(
-            undefined,
-            undefined,
-            "url",
-            undefined,
-            this.factory.createUnionTypeNode([
-              this.factory.createTypeReferenceNode("string"),
-              this.factory.createTypeReferenceNode("URL"),
-            ]),
-          ),
-          this.factory.createParameterDeclaration(
-            undefined,
-            undefined,
-            "init",
-            this.factory.createToken(ts.SyntaxKind.QuestionToken),
-            this.factory.createTypeReferenceNode("ZapierFetchInitOptions"),
-          ),
-        ],
-        this.factory.createTypeReferenceNode("Promise", [
-          this.factory.createTypeReferenceNode("Response"),
-        ]),
-      ),
-    );
-
-    // Add JSDoc comment
-    property = ts.addSyntheticLeadingComment(
-      property,
-      ts.SyntaxKind.MultiLineCommentTrivia,
-      "* Make authenticated HTTP requests through Zapier's Relay service ",
-      true,
-    );
-
-    return property;
-  }
-
-  private createAppFactoryInterface(appName: string): ts.InterfaceDeclaration {
-    const callSignature = this.factory.createCallSignature(
-      undefined,
-      [
-        this.factory.createParameterDeclaration(
-          undefined,
-          undefined,
-          "options",
-          undefined,
-          this.factory.createTypeLiteralNode([
-            this.factory.createPropertySignature(
-              undefined,
-              "authenticationId",
-              undefined,
-              this.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-            ),
-          ]),
-        ),
-      ],
-      this.factory.createTypeReferenceNode(`${appName}AppProxy`),
-    );
-
-    return this.factory.createInterfaceDeclaration(
-      undefined,
-      `${appName}AppFactory`,
-      undefined,
-      undefined,
-      [callSignature],
-    );
-  }
-
-  private createAppWithFactoryType(appName: string): ts.TypeAliasDeclaration {
-    return this.factory.createTypeAliasDeclaration(
-      undefined,
-      `${appName}AppWithFactory`,
-      undefined,
-      this.factory.createIntersectionTypeNode([
-        this.factory.createTypeReferenceNode(`${appName}AppFactory`),
-        this.factory.createTypeReferenceNode(`${appName}AppProxy`),
-      ]),
-    );
-  }
-
-  private createModuleAugmentation(
-    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"),
-      this.factory.createModuleBlock([
-        this.factory.createInterfaceDeclaration(
-          undefined,
-          "ZapierSdkApps",
-          undefined,
-          undefined,
-          properties,
-        ),
-      ]),
-    );
-  }
-
-  private mapFieldTypeToTypeNode(field: InputFieldItem): ts.TypeNode {
-    // TODO: Handle choices when needed - choices are handled separately through listInputFieldChoices
-
-    // Map Zapier field types to TypeScript types
-    // Handle the new enum types from InputFieldItem.value_type
-    switch (field.value_type?.toLowerCase()) {
-      case "string":
-      case "text":
-      case "email":
-      case "url":
-      case "password":
-      case "datetime":
-      case "date":
-      case "file":
-        return this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
-      case "integer":
-      case "number":
-        return this.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-      case "boolean":
-        return this.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
-      case "array":
-        return this.factory.createArrayTypeNode(
-          this.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-        );
-      case "object":
-        return this.factory.createTypeReferenceNode("Record", [
-          this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-          this.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-        ]);
-      default:
-        // Default to string | number | boolean for unknown types
-        return this.factory.createUnionTypeNode([
-          this.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-          this.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
-          this.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
-        ]);
-    }
-  }
-
-  private capitalize(str: string): string {
-    return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-  }
-
-  private sanitizeActionName(actionKey: string): string {
-    // Ensure the action name is a valid TypeScript identifier
-    let sanitized = actionKey.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 sanitizeFieldName(fieldKey: string): string {
-    // Ensure the field name is a valid TypeScript identifier
-    let sanitized = fieldKey.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 escapeComment(comment: string): string {
-    // 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);
-  }
-}