@zapier/zapier-sdk-cli 0.13.8 → 0.13.10

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

@@ -1,12 +1,9 @@
-import { createFunction } from "@zapier/zapier-sdk";
+import { createFunction, ZapierValidationError, ZapierUnknownError, } from "@zapier/zapier-sdk";
 import { BuildManifestSchema, } from "./schemas";
 import { createManifestEntry } from "../../utils/manifest-helpers";
 export const buildManifestPlugin = ({ sdk, context }) => {
     const buildManifest = createFunction(async function buildManifest(options) {
         const { appKeys, skipWrite = false, configPath, onProgress } = options;
-        const result = {
-            errors: [],
-        };
         // Get apps using listApps (which respects existing manifest for version locking)
         onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
         const appsIterator = sdk.listApps({ appKeys }).items();
@@ -17,7 +14,7 @@ export const buildManifestPlugin = ({ sdk, context }) => {
         }
         onProgress?.({ type: "apps_lookup_complete", count: apps.length });
         if (apps.length === 0) {
-            return result;
+            return {};
         }
         let updatedManifest;
         // Process each app
@@ -52,20 +49,23 @@ export const buildManifestPlugin = ({ sdk, context }) => {
                 onProgress?.({ type: "app_processing_complete", appKey: app.key });
             }
             catch (error) {
-                const errorMessage = `Failed to process app: ${error}`;
-                result.errors.push({
-                    appKey: app.key,
-                    error: errorMessage,
-                });
+                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
+                    });
+                }
             }
         }
-        result.manifest = updatedManifest;
-        return result;
+        return { manifest: updatedManifest };
     }, BuildManifestSchema);
     return {
         buildManifest,

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

@@ -49,8 +49,4 @@ export type ManifestBuildProgressEvent = {
 };
 export interface BuildManifestResult {
     manifest?: Manifest;
-    errors: Array<{
-        appKey: string;
-        error: string;
-    }>;
 }

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;
-    }>;
 }

package/dist/src/sdk.d.ts

@@ -1,15 +1,6 @@
 import { type ZapierSdkOptions } from "@zapier/zapier-sdk";
 import type { ZapierSdkCli } from "./types/sdk";
 export interface ZapierCliSdkOptions extends ZapierSdkOptions {
-    debug?: boolean;
-    eventEmission?: {
-        enabled?: boolean;
-        transport?: {
-            type: "http" | "console" | "noop";
-            endpoint?: string;
-            headers?: Record<string, string>;
-        };
-    };
 }
 /**
  * Create a Zapier SDK instance configured specifically for the CLI

package/dist/src/sdk.js

@@ -8,8 +8,7 @@ export function createZapierCliSdk(options = {}) {
     // Create SDK instance and chain all plugins
     // Chaining prevents type widening that occurs with let reassignment
     return (createZapierSdkWithoutRegistry({
-        debug: options.debug,
-        eventEmission: options.eventEmission,
+        ...options,
     })
         // Add CLI-specific plugins before registry
         .addPlugin(generateAppTypesPlugin)