@zapier/zapier-sdk-cli 0.8.4 → 0.10.0

package/src/plugins/generateTypes/index.ts

@@ -1,444 +0,0 @@
-import type {
-  Action,
-  ActionField,
-  ActionItem,
-  Plugin,
-  GetSdkType,
-  ListActionsPluginProvides,
-  ListInputFieldsPluginProvides,
-  ManifestPluginProvides,
-} from "@zapier/zapier-sdk";
-import { GenerateTypesSchema, type GenerateTypesOptions } from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
-import * as fs from "fs";
-import * as path from "path";
-
-export interface GenerateTypesPluginProvides {
-  generateTypes: (options: GenerateTypesOptions) => Promise<string>;
-  context: {
-    meta: {
-      generateTypes: {
-        inputSchema: typeof GenerateTypesSchema;
-      };
-    };
-  };
-}
-
-export const generateTypesPlugin: Plugin<
-  GetSdkType<
-    ListActionsPluginProvides &
-      ListInputFieldsPluginProvides &
-      ManifestPluginProvides
-  >, // requires these SDK methods
-  {}, // requires no context
-  GenerateTypesPluginProvides
-> = ({ sdk }) => {
-  const generateTypesWithSdk = createFunction(
-    async function generateTypesWithSdk(
-      options: GenerateTypesOptions,
-    ): Promise<string> {
-      return await generateTypes({ ...options, sdk });
-    },
-    GenerateTypesSchema,
-  );
-
-  return {
-    generateTypes: generateTypesWithSdk,
-    context: {
-      meta: {
-        generateTypes: {
-          categories: ["utility"],
-          inputSchema: GenerateTypesSchema,
-        },
-      },
-    },
-  };
-};
-
-interface ActionWithActionFields extends Omit<Action, "inputFields" | "type"> {
-  inputFields: ActionField[];
-  app_key: string;
-  action_type: Action["type"];
-  title: string;
-  type: "action";
-}
-
-/**
- * Generate the fetch method signature for app proxies
- */
-function generateFetchMethodSignature(): string {
-  return `  /** Make authenticated HTTP requests through Zapier's Relay service */
-  fetch: (options: Omit<z.infer<typeof RelayFetchSchema>, 'authenticationId'>) => Promise<Response>`;
-}
-
-/**
- * Generate TypeScript types for a specific app (CLI version)
- */
-export async function generateTypes(
-  options: GenerateTypesOptions & {
-    sdk: GetSdkType<
-      ListActionsPluginProvides &
-        ListInputFieldsPluginProvides &
-        ManifestPluginProvides
-    >;
-  },
-): Promise<string> {
-  const {
-    appKey,
-    authenticationId,
-    output = `./types/${appKey}.d.ts`,
-    sdk,
-  } = options;
-
-  // Parse app identifier (support app@version format)
-  const { app, version } = parseAppIdentifier(appKey);
-
-  // Fetch all actions for the app
-  const actionsResult = await sdk.listActions({
-    appKey: app,
-  });
-
-  const actions = actionsResult.data;
-
-  if (actions.length === 0) {
-    const typeDefinitions = generateEmptyTypesFile(app, version);
-
-    if (output) {
-      fs.mkdirSync(path.dirname(output), { recursive: true });
-      fs.writeFileSync(output, typeDefinitions, "utf8");
-    }
-
-    return typeDefinitions;
-  }
-
-  // Fetch input fields for each action
-  const actionsWithFields: ActionWithActionFields[] = [];
-
-  if (authenticationId) {
-    for (const action of actions) {
-      try {
-        // Check to see if the appKey is in the manifest
-        const manifestEntry = sdk.getContext().getManifestEntry(appKey);
-
-        const fieldsResult = await sdk.listInputFields({
-          // If the appKey is in the manifest, use the appKey so that the types are consistent with the manifest's version, otherwise use the action.app_key
-          appKey: manifestEntry ? appKey : action.app_key,
-          actionKey: action.key,
-          actionType: action.action_type,
-          authenticationId: authenticationId,
-        });
-
-        const fields = fieldsResult.data.map((field: unknown): ActionField => {
-          const fieldObj = field as {
-            is_required?: boolean;
-            required?: boolean;
-            [key: string]: unknown;
-          };
-          return {
-            ...fieldObj,
-            required: fieldObj.is_required || fieldObj.required || false,
-          } as ActionField;
-        });
-        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,
-        });
-      }
-    }
-  } else {
-    // Convert actions to have empty input fields (will generate generic types)
-    actions.forEach((action: ActionItem) => {
-      actionsWithFields.push({
-        ...action,
-        inputFields: [],
-        name: action.title || action.key,
-      });
-    });
-  }
-
-  // Generate TypeScript types
-  const typeDefinitions = generateTypeDefinitions(
-    app,
-    actionsWithFields,
-    version,
-  );
-
-  // Write to file if output path specified
-  if (output) {
-    fs.mkdirSync(path.dirname(output), { recursive: true });
-    fs.writeFileSync(output, typeDefinitions, "utf8");
-  }
-
-  return typeDefinitions;
-}
-
-function parseAppIdentifier(identifier: string): {
-  app: string;
-  version?: string;
-} {
-  const parts = identifier.split("@");
-  return {
-    app: parts[0],
-    version: parts[1],
-  };
-}
-
-function generateTypeDefinitions(
-  appKey: string,
-  actions: ActionWithActionFields[],
-  version?: string,
-): string {
-  // Handle empty actions
-  if (actions.length === 0) {
-    return generateEmptyTypesFile(appKey, version);
-  }
-
-  // Group actions by type
-  const actionsByType = actions.reduce(
-    (acc, action) => {
-      if (!acc[action.action_type]) {
-        acc[action.action_type] = [];
-      }
-      acc[action.action_type].push(action);
-      return acc;
-    },
-    {} as Record<string, ActionWithActionFields[]>,
-  );
-
-  const appName = capitalize(appKey);
-  const versionComment = version
-    ? ` * Generated for ${appKey}@${version}`
-    : ` * Generated for ${appKey}`;
-
-  let output = `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${new Date().toISOString()}
- * 
- * Usage:
- *   import type { ${appName}Sdk } from './path/to/this/file'
- *   const sdk = createZapierSdk() as unknown as ${appName}Sdk
- *   
- *   // Direct usage (per-call auth):
- *   await sdk.apps.${appKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
- *   
- *   // Factory usage (pinned auth):
- *   const my${appName} = sdk.apps.${appKey}({ authenticationId: 123 })
- *   await my${appName}.search.user_by_email({ inputs: { email } })
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-`;
-
-  // Generate input types for each action
-  actions.forEach((action) => {
-    if (action.inputFields.length > 0) {
-      const inputTypeName = `${appName}${capitalize(action.action_type)}${capitalize(
-        sanitizeActionName(action.key),
-      )}Inputs`;
-
-      output += `interface ${inputTypeName} {\n`;
-
-      action.inputFields.forEach((field) => {
-        const isOptional = !field.required;
-        const fieldType = mapFieldTypeToTypeScript(field);
-        const description = field.helpText
-          ? `  /** ${escapeComment(field.helpText)} */\n`
-          : "";
-
-        output += `${description}  ${sanitizeFieldName(field.key)}${
-          isOptional ? "?" : ""
-        }: ${fieldType}\n`;
-      });
-
-      output += `}\n\n`;
-    }
-  });
-
-  // Generate action type interfaces for each action type
-  Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-
-    output += `interface ${typeName} {\n`;
-
-    typeActions.forEach((action: ActionWithActionFields) => {
-      const actionName = sanitizeActionName(action.key);
-      const description = action.description
-        ? `  /** ${escapeComment(action.description)} */\n`
-        : "";
-
-      // Generate type-safe action method signature
-      if (action.inputFields.length > 0) {
-        const inputTypeName = `${appName}${capitalize(action.action_type)}${capitalize(
-          sanitizeActionName(action.key),
-        )}Inputs`;
-        output += `${description}  ${actionName}: (options: { inputs: ${inputTypeName} } & Omit<ActionExecutionOptions, 'inputs'>) => Promise<ActionExecutionResult>\n`;
-      } else {
-        // No specific input fields available - use generic Record<string, any> for inputs
-        output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>\n`;
-      }
-    });
-
-    output += `}\n\n`;
-  });
-
-  // Generate the main app SDK interface with factory pattern support
-
-  // Generate the app proxy interface (actions grouped by type)
-  output += `interface ${appName}AppProxy {\n`;
-  Object.keys(actionsByType).forEach((actionType) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-    output += `  ${actionType}: ${typeName}\n`;
-  });
-  // Always include fetch method for authenticated HTTP requests
-  output += generateFetchMethodSignature() + "\n";
-  output += `}\n\n`;
-
-  // Generate the factory function interface
-  output += `interface ${appName}AppFactory {\n`;
-  output += `  (options: { authenticationId: number }): ${appName}AppProxy\n`;
-  output += `}\n\n`;
-
-  // Combine factory and direct access
-  output += `type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy\n\n`;
-
-  // Generate the main SDK interface
-  output += `export interface ${appName}Sdk {\n`;
-  output += `  apps: {\n`;
-  output += `    ${appKey}: ${appName}AppWithFactory\n`;
-  output += `  }\n`;
-  output += `}\n`;
-
-  return output;
-}
-
-function generateEmptyTypesFile(appKey: string, version?: string): string {
-  const appName = capitalize(appKey);
-  const versionComment = version
-    ? ` * Generated for ${appKey}@${version}`
-    : ` * Generated for ${appKey}`;
-
-  return `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${new Date().toISOString()}
- * 
- * No actions found for this app.
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-interface ${appName}AppProxy {
-  // No actions available
-${generateFetchMethodSignature()}
-}
-
-interface ${appName}AppFactory {
-  (options: { authenticationId: number }): ${appName}AppProxy
-}
-
-type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
-
-export interface ${appName}Sdk {
-  apps: {
-    ${appKey}: ${appName}AppWithFactory
-  }
-}
-`;
-}
-
-function capitalize(str: string): string {
-  return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-}
-
-function 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;
-}
-
-function 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;
-}
-
-function escapeComment(comment: string): string {
-  // Escape comment text to prevent breaking the JSDoc comment
-  return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
-}
-
-function mapFieldTypeToTypeScript(field: ActionField): string {
-  // Handle choices (enum-like fields)
-  if (field.choices && field.choices.length > 0) {
-    const choiceValues = field.choices
-      .filter(
-        (choice) =>
-          choice.value !== undefined &&
-          choice.value !== null &&
-          choice.value !== "",
-      )
-      .map((choice) =>
-        typeof choice.value === "string" ? `"${choice.value}"` : choice.value,
-      );
-
-    if (choiceValues.length > 0) {
-      return choiceValues.join(" | ");
-    }
-    // If all choices were filtered out, fall through to default type handling
-  }
-
-  // Map Zapier field types to TypeScript types
-  switch (field.type?.toLowerCase()) {
-    case "string":
-    case "text":
-    case "email":
-    case "url":
-    case "password":
-      return "string";
-    case "integer":
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "datetime":
-    case "date":
-      return "string"; // ISO date strings
-    case "file":
-      return "string"; // File URL or content
-    case "array":
-      return "any[]";
-    case "object":
-      return "Record<string, any>";
-    default:
-      // Default to string for unknown types, with union for common cases
-      return "string | number | boolean";
-  }
-}

package/src/plugins/generateTypes/schemas.ts

@@ -1,23 +0,0 @@
-import { z } from "zod";
-import {
-  AppKeyPropertySchema,
-  AuthenticationIdPropertySchema,
-  OutputPropertySchema,
-} from "@zapier/zapier-sdk";
-
-// Generate types schema - mirrors the original from SDK but for CLI use
-export const GenerateTypesSchema = z
-  .object({
-    appKey: AppKeyPropertySchema.describe("App key to generate SDK code for"),
-    authenticationId: AuthenticationIdPropertySchema.optional(),
-    output: OutputPropertySchema.optional().describe(
-      "Output file path (defaults to generated/<appKey>.ts)",
-    ),
-    lockFilePath: z
-      .string()
-      .optional()
-      .describe("Path to the .zapierrc lock file (defaults to .zapierrc)"),
-  })
-  .describe("Generate TypeScript SDK code for a specific app");
-
-export type GenerateTypesOptions = z.infer<typeof GenerateTypesSchema>;

package/src/plugins/getConfigPath/index.ts

@@ -1,42 +0,0 @@
-import type { Plugin } from "@zapier/zapier-sdk";
-import { GetConfigPathSchema, type GetConfigPathOptions } from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
-import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
-
-export interface GetConfigPathPluginProvides {
-  getConfigPath: (options?: GetConfigPathOptions) => Promise<string>;
-  context: {
-    meta: {
-      getConfigPath: {
-        inputSchema: typeof GetConfigPathSchema;
-      };
-    };
-  };
-}
-
-export const getConfigPathPlugin: Plugin<
-  {}, // requires no existing SDK methods
-  {}, // requires no context
-  GetConfigPathPluginProvides
-> = () => {
-  const getConfigPathWithSdk = createFunction(
-    async function getConfigPathWithSdk(
-      _options?: GetConfigPathOptions,
-    ): Promise<string> {
-      return getConfigPath();
-    },
-    GetConfigPathSchema,
-  );
-
-  return {
-    getConfigPath: getConfigPathWithSdk,
-    context: {
-      meta: {
-        getConfigPath: {
-          categories: ["utility"],
-          inputSchema: GetConfigPathSchema,
-        },
-      },
-    },
-  };
-};

package/src/plugins/getConfigPath/schemas.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-
-// Get config path schema - simple command with no parameters
-export const GetConfigPathSchema = z
-  .object({})
-  .describe("Show the path to the configuration file");
-
-export type GetConfigPathOptions = z.infer<typeof GetConfigPathSchema>;