@zapier/zapier-sdk-cli 0.8.4 → 0.9.0

package/dist/src/plugins/generateTypes/index.js

@@ -1,312 +0,0 @@
-import { GenerateTypesSchema } from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
-import * as fs from "fs";
-import * as path from "path";
-export const generateTypesPlugin = ({ sdk }) => {
-    const generateTypesWithSdk = createFunction(async function generateTypesWithSdk(options) {
-        return await generateTypes({ ...options, sdk });
-    }, GenerateTypesSchema);
-    return {
-        generateTypes: generateTypesWithSdk,
-        context: {
-            meta: {
-                generateTypes: {
-                    categories: ["utility"],
-                    inputSchema: GenerateTypesSchema,
-                },
-            },
-        },
-    };
-};
-/**
- * Generate the fetch method signature for app proxies
- */
-function generateFetchMethodSignature() {
-    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) {
-    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 = [];
-    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) => {
-                    const fieldObj = field;
-                    return {
-                        ...fieldObj,
-                        required: fieldObj.is_required || fieldObj.required || false,
-                    };
-                });
-                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) => {
-            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) {
-    const parts = identifier.split("@");
-    return {
-        app: parts[0],
-        version: parts[1],
-    };
-}
-function generateTypeDefinitions(appKey, actions, version) {
-    // 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;
-    }, {});
-    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) => {
-            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, version) {
-    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) {
-    return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-}
-function sanitizeActionName(actionKey) {
-    // 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) {
-    // 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) {
-    // Escape comment text to prevent breaking the JSDoc comment
-    return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
-}
-function mapFieldTypeToTypeScript(field) {
-    // 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/dist/src/plugins/generateTypes/schemas.d.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-export declare const GenerateTypesSchema: z.ZodObject<{
-    appKey: z.ZodString;
-    authenticationId: z.ZodOptional<z.ZodNumber>;
-    output: z.ZodOptional<z.ZodString>;
-    lockFilePath: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKey: string;
-    authenticationId?: number | undefined;
-    output?: string | undefined;
-    lockFilePath?: string | undefined;
-}, {
-    appKey: string;
-    authenticationId?: number | undefined;
-    output?: string | undefined;
-    lockFilePath?: string | undefined;
-}>;
-export type GenerateTypesOptions = z.infer<typeof GenerateTypesSchema>;

package/dist/src/plugins/generateTypes/schemas.js

@@ -1,14 +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");

package/dist/src/plugins/getConfigPath/index.d.ts

@@ -1,15 +0,0 @@
-import type { Plugin } from "@zapier/zapier-sdk";
-import { GetConfigPathSchema, type GetConfigPathOptions } from "./schemas";
-export interface GetConfigPathPluginProvides {
-    getConfigPath: (options?: GetConfigPathOptions) => Promise<string>;
-    context: {
-        meta: {
-            getConfigPath: {
-                inputSchema: typeof GetConfigPathSchema;
-            };
-        };
-    };
-}
-export declare const getConfigPathPlugin: Plugin<{}, // requires no existing SDK methods
-{}, // requires no context
-GetConfigPathPluginProvides>;

package/dist/src/plugins/getConfigPath/index.js

@@ -1,19 +0,0 @@
-import { GetConfigPathSchema } from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
-import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
-export const getConfigPathPlugin = () => {
-    const getConfigPathWithSdk = createFunction(async function getConfigPathWithSdk(_options) {
-        return getConfigPath();
-    }, GetConfigPathSchema);
-    return {
-        getConfigPath: getConfigPathWithSdk,
-        context: {
-            meta: {
-                getConfigPath: {
-                    categories: ["utility"],
-                    inputSchema: GetConfigPathSchema,
-                },
-            },
-        },
-    };
-};

package/dist/src/plugins/getConfigPath/schemas.d.ts

@@ -1,3 +0,0 @@
-import { z } from "zod";
-export declare const GetConfigPathSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export type GetConfigPathOptions = z.infer<typeof GetConfigPathSchema>;

package/dist/src/plugins/getConfigPath/schemas.js

@@ -1,5 +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");