@zapier/zapier-sdk-cli 0.13.9 → 0.13.10

package/src/plugins/generateAppTypes/index.ts

@@ -8,7 +8,11 @@ import type {
   ManifestPluginProvides,
   AppItem,
 } from "@zapier/zapier-sdk";
-import { createFunction } from "@zapier/zapier-sdk";
+import {
+  createFunction,
+  ZapierValidationError,
+  ZapierUnknownError,
+} from "@zapier/zapier-sdk";
 import {
   GenerateAppTypesSchema,
   type GenerateAppTypesOptions,
@@ -17,7 +21,8 @@ import {
 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 interface GenerateAppTypesPluginProvides {
   generateAppTypes: (
@@ -50,20 +55,14 @@ export const generateAppTypesPlugin: Plugin<
       appKeys,
       authenticationIds,
       skipWrite = false,
-      typesOutputDirectory,
+      typesOutputDirectory = await detectTypesOutputDirectory(),
       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 resolvedTypesOutput = resolve(typesOutputDirectory);
 
     const result: GenerateAppTypesResult = {
       typeDefinitions: {},
-      errors: [],
     };
 
     // Get apps using listApps (which respects existing manifest for version locking)
@@ -100,8 +99,8 @@ export const generateAppTypesPlugin: Plugin<
     }
 
     // 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
@@ -119,17 +118,18 @@ export const generateAppTypesPlugin: Plugin<
 
       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
@@ -158,63 +158,55 @@ export const generateAppTypesPlugin: Plugin<
         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,
+        });
 
-          onProgress?.({
-            type: "type_generated",
-            manifestKey,
-            sizeBytes: typeDefinitionString.length,
-          });
+        result.typeDefinitions[manifestKey] = typeDefinitionString;
 
-          // Write to file if skipWrite is false
-          if (!skipWrite && typesOutputDirectory && result.writtenFiles) {
-            const filePath = join(typesOutputDirectory, `${manifestKey}.d.ts`);
-            await writeFile(filePath, typeDefinitionString, "utf8");
+        onProgress?.({
+          type: "type_generated",
+          manifestKey,
+          sizeBytes: typeDefinitionString.length,
+        });
 
-            result.writtenFiles[manifestKey] = filePath;
+        // Write to file if skipWrite is false
+        if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
+          const filePath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+          await writeFile(filePath, typeDefinitionString, "utf8");
 
-            onProgress?.({
-              type: "file_written",
-              manifestKey,
-              filePath,
-            });
-          }
+          result.writtenFiles[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,
+            type: "file_written",
+            manifestKey,
+            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
+          });
+        }
       }
     }
 

package/src/plugins/generateAppTypes/schemas.ts

@@ -58,8 +58,4 @@ export type AppTypesProgressEvent =
 export interface GenerateAppTypesResult {
   typeDefinitions: Record<string, string>; // manifestKey -> type definition string
   writtenFiles?: Record<string, string>; // manifestKey -> file path (only when skipWrite is false)
-  errors: Array<{
-    appKey: string;
-    error: string;
-  }>;
 }