@zapier/zapier-sdk-cli 0.13.9 → 0.13.10

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

@@ -1,19 +1,16 @@
-import { createFunction } from "@zapier/zapier-sdk";
+import { createFunction, ZapierValidationError, ZapierUnknownError, } from "@zapier/zapier-sdk";
 import { GenerateAppTypesSchema, } from "./schemas";
 import { AstTypeGenerator } from "../../generators/ast-generator";
 import { getManifestKey } from "../../utils/manifest-helpers";
 import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
+import { join, resolve } from "path";
+import { detectTypesOutputDirectory } from "../../utils/directory-detection";
 export const generateAppTypesPlugin = ({ sdk }) => {
     const generateAppTypes = createFunction(async function generateAppTypes(options) {
-        const { appKeys, authenticationIds, skipWrite = false, typesOutputDirectory, onProgress, } = options;
-        // Validate that typesOutputDirectory is provided when skipWrite is false
-        if (!skipWrite && !typesOutputDirectory) {
-            throw new Error("typesOutputDirectory is required when skipWrite is false");
-        }
+        const { appKeys, authenticationIds, skipWrite = false, typesOutputDirectory = await detectTypesOutputDirectory(), onProgress, } = options;
+        const resolvedTypesOutput = resolve(typesOutputDirectory);
         const result = {
             typeDefinitions: {},
-            errors: [],
         };
         // Get apps using listApps (which respects existing manifest for version locking)
         onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
@@ -46,8 +43,8 @@ export const generateAppTypesPlugin = ({ sdk }) => {
             });
         }
         // Ensure output directory exists if we're writing files
-        if (!skipWrite && typesOutputDirectory) {
-            await mkdir(typesOutputDirectory, { recursive: true });
+        if (!skipWrite && resolvedTypesOutput) {
+            await mkdir(resolvedTypesOutput, { recursive: true });
         }
         // Initialize writtenFiles if we're writing to disk
         if (!skipWrite) {
@@ -62,17 +59,18 @@ export const generateAppTypesPlugin = ({ sdk }) => {
             });
             try {
                 if (!app.version) {
-                    const error = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
-                    result.errors.push({
-                        appKey: app.key,
-                        error,
-                    });
+                    const errorMessage = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
                     onProgress?.({
                         type: "app_processing_error",
                         appKey: app.key,
-                        error,
+                        error: errorMessage,
+                    });
+                    throw new ZapierValidationError(errorMessage, {
+                        details: {
+                            appKey: app.key,
+                            implementationId: app.implementation_id,
+                        },
                     });
-                    continue;
                 }
                 // Find matching authentication for this app if authentications were provided
                 let authenticationId;
@@ -98,59 +96,49 @@ export const generateAppTypesPlugin = ({ sdk }) => {
                 }
                 const manifestKey = getManifestKey(app);
                 // Generate type definitions
-                try {
-                    const generator = new AstTypeGenerator();
-                    const typeDefinitionString = await generator.generateTypes({
-                        app,
-                        authenticationId,
-                        sdk,
-                    });
-                    result.typeDefinitions[manifestKey] = typeDefinitionString;
+                const generator = new AstTypeGenerator();
+                const typeDefinitionString = await generator.generateTypes({
+                    app,
+                    authenticationId,
+                    sdk,
+                });
+                result.typeDefinitions[manifestKey] = typeDefinitionString;
+                onProgress?.({
+                    type: "type_generated",
+                    manifestKey,
+                    sizeBytes: typeDefinitionString.length,
+                });
+                // Write to file if skipWrite is false
+                if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
+                    const filePath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+                    await writeFile(filePath, typeDefinitionString, "utf8");
+                    result.writtenFiles[manifestKey] = filePath;
                     onProgress?.({
-                        type: "type_generated",
+                        type: "file_written",
                         manifestKey,
-                        sizeBytes: typeDefinitionString.length,
-                    });
-                    // Write to file if skipWrite is false
-                    if (!skipWrite && typesOutputDirectory && result.writtenFiles) {
-                        const filePath = join(typesOutputDirectory, `${manifestKey}.d.ts`);
-                        await writeFile(filePath, typeDefinitionString, "utf8");
-                        result.writtenFiles[manifestKey] = filePath;
-                        onProgress?.({
-                            type: "file_written",
-                            manifestKey,
-                            filePath,
-                        });
-                    }
-                    onProgress?.({
-                        type: "app_processing_complete",
-                        appKey: app.key,
-                    });
-                }
-                catch (error) {
-                    const errorMessage = `Failed to generate types: ${error}`;
-                    result.errors.push({
-                        appKey: app.key,
-                        error: errorMessage,
-                    });
-                    onProgress?.({
-                        type: "app_processing_error",
-                        appKey: app.key,
-                        error: errorMessage,
+                        filePath,
                     });
                 }
-            }
-            catch (error) {
-                const errorMessage = `Failed to process app: ${error}`;
-                result.errors.push({
+                onProgress?.({
+                    type: "app_processing_complete",
                     appKey: app.key,
-                    error: errorMessage,
                 });
+            }
+            catch (error) {
+                const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
                 onProgress?.({
                     type: "app_processing_error",
                     appKey: app.key,
                     error: errorMessage,
                 });
+                if (error instanceof ZapierValidationError) {
+                    throw error; // Preserve the specific error type
+                }
+                else {
+                    throw new ZapierUnknownError(errorMessage, {
+                        cause: error, // Works for both Error and non-Error
+                    });
+                }
             }
         }
         return result;

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

@@ -65,8 +65,4 @@ export type AppTypesProgressEvent = {
 export interface GenerateAppTypesResult {
     typeDefinitions: Record<string, string>;
     writtenFiles?: Record<string, string>;
-    errors: Array<{
-        appKey: string;
-        error: string;
-    }>;
 }