@zapier/zapier-sdk-cli 0.19.0 → 0.22.0

package/dist/src/utils/schema-formatter.d.ts

@@ -1,6 +0,0 @@
-import type { z } from "zod";
-export declare function formatJsonOutput(data: unknown): void;
-export declare function formatItemsFromSchema(functionInfo: {
-    inputSchema: z.ZodType;
-    outputSchema?: z.ZodType;
-}, items: unknown[], startingNumber?: number): void;

package/dist/src/utils/schema-formatter.js

@@ -1,115 +0,0 @@
-import chalk from "chalk";
-import util from "util";
-// These functions are internal to SDK, implementing basic formatting fallback
-// TODO: Consider exposing these utilities or implementing proper CLI formatting
-function getFormatMetadata(schema) {
-    return schema?._zod
-        ?.def?.formatMeta;
-}
-function getOutputSchema(schema) {
-    return schema?._zod?.def
-        ?.outputSchema;
-}
-// ============================================================================
-// JSON Formatting
-// ============================================================================
-export function formatJsonOutput(data) {
-    // Don't print anything for undefined results (commands that just perform actions)
-    if (data === undefined) {
-        return;
-    }
-    // Use util.inspect for colored output
-    console.log(util.inspect(data, { colors: true, depth: null, breakLength: 80 }));
-}
-// ============================================================================
-// Generic Schema-Driven Formatter
-// ============================================================================
-export function formatItemsFromSchema(functionInfo, items, startingNumber = 0) {
-    // Get the output schema from function info or fall back to input schema output schema
-    const outputSchema = functionInfo.outputSchema || getOutputSchema(functionInfo.inputSchema);
-    if (!outputSchema) {
-        // Fallback to generic formatting if no output schema
-        formatItemsGeneric(items, startingNumber);
-        return;
-    }
-    const formatMeta = getFormatMetadata(outputSchema);
-    if (!formatMeta) {
-        // Fallback to generic formatting if no format metadata
-        formatItemsGeneric(items, startingNumber);
-        return;
-    }
-    // Format each item using the schema metadata
-    items.forEach((item, index) => {
-        const formatted = formatMeta.format(item);
-        formatSingleItem(formatted, startingNumber + index);
-    });
-}
-function formatSingleItem(formatted, itemNumber) {
-    // Build the main title line with optional subtitle
-    let titleLine = `${chalk.gray(`${itemNumber + 1}.`)} ${chalk.cyan(formatted.title)}`;
-    // Generate subtitle - always show key if available, then ID if available
-    const subtitleParts = [];
-    if (formatted.keys) {
-        subtitleParts.push(...formatted.keys);
-    }
-    else if (formatted.key) {
-        subtitleParts.push(formatted.key);
-    }
-    if (formatted.id) {
-        subtitleParts.push(formatted.id);
-    }
-    // Remove duplicates while preserving order
-    const uniqueParts = [...new Set(subtitleParts)];
-    if (uniqueParts.length > 0) {
-        titleLine += ` ${chalk.gray(`(${uniqueParts.join(", ")})`)}`;
-    }
-    console.log(titleLine);
-    // Show description if available
-    if (formatted.description) {
-        console.log(`   ${chalk.dim(formatted.description)}`);
-    }
-    // If data is provided, use JSON formatting instead of details
-    if (formatted.data !== undefined) {
-        formatJsonOutput(formatted.data);
-        console.log(); // Empty line between items
-        return;
-    }
-    // Format detail lines
-    for (const detail of formatted.details) {
-        const styledText = applyStyle(detail.text, detail.style);
-        console.log(`   ${styledText}`);
-    }
-    console.log(); // Empty line between items
-}
-function applyStyle(value, style) {
-    switch (style) {
-        case "dim":
-            return chalk.dim(value);
-        case "accent":
-            return chalk.magenta(value);
-        case "warning":
-            return chalk.red(value);
-        case "success":
-            return chalk.green(value);
-        case "normal":
-        default:
-            return chalk.blue(value);
-    }
-}
-function convertGenericItemToFormattedItem(item) {
-    const itemObj = item;
-    return {
-        title: itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item",
-        id: itemObj.id,
-        key: itemObj.key,
-        description: itemObj.description,
-        details: [],
-    };
-}
-function formatItemsGeneric(items, startingNumber = 0) {
-    // Convert generic items to FormattedItem and use formatSingleItem
-    items.forEach((item, index) => {
-        const formatted = convertGenericItemToFormattedItem(item);
-        formatSingleItem(formatted, startingNumber + index);
-    });
-}

package/dist/src/utils/serializeAsync.d.ts

@@ -1,2 +0,0 @@
-declare const serializeAsync: <R, A extends []>(fn: (...args: A) => Promise<R>) => ((...args: A) => Promise<R>);
-export default serializeAsync;

package/dist/src/utils/serializeAsync.js

@@ -1,16 +0,0 @@
-import { createHash } from "node:crypto";
-const promises = {};
-const serializeAsync = (fn) => async (...args) => {
-    const hash = createHash("sha256")
-        .update(fn.toString(), "utf8")
-        .digest()
-        .toString("hex");
-    const promise = promises[hash];
-    if (!promise) {
-        promises[hash] = fn(...args).finally(() => {
-            delete promises[hash];
-        });
-    }
-    return promises[hash];
-};
-export default serializeAsync;

package/dist/src/utils/spinner.d.ts

@@ -1 +0,0 @@
-export declare const spinPromise: <T>(promise: Promise<T>, text: string) => Promise<T>;

package/dist/src/utils/spinner.js

@@ -1,21 +0,0 @@
-import ora from "ora";
-import { ZapierCliUserCancellationError } from "./errors";
-export const spinPromise = async (promise, text) => {
-    const spinner = ora(text).start();
-    try {
-        const result = await promise;
-        spinner.succeed();
-        return result;
-    }
-    catch (error) {
-        if (error instanceof ZapierCliUserCancellationError) {
-            // For user cancellation, just stop the spinner without showing failure
-            spinner.stop();
-        }
-        else {
-            // For actual errors, show failure
-            spinner.fail();
-        }
-        throw error;
-    }
-};

package/dist/src/utils/version-checker.d.ts

@@ -1,17 +0,0 @@
-interface VersionInfo {
-    hasUpdate: boolean;
-    latestVersion?: string;
-    currentVersion: string;
-    isDeprecated: boolean;
-    deprecationMessage?: string;
-}
-export declare function checkForUpdates({ packageName, currentVersion, }: {
-    packageName: string;
-    currentVersion: string;
-}): Promise<VersionInfo>;
-export declare function displayUpdateNotification(versionInfo: VersionInfo, packageName: string): void;
-export declare function checkAndNotifyUpdates({ packageName, currentVersion, }: {
-    packageName: string;
-    currentVersion: string;
-}): Promise<void>;
-export {};

package/dist/src/utils/version-checker.js

@@ -1,156 +0,0 @@
-import packageJsonLib from "package-json";
-import chalk from "chalk";
-import log from "./log";
-import Conf from "conf";
-import { getUpdateCommand } from "./package-manager-detector";
-import semver from "semver";
-let config = null;
-function getConfig() {
-    if (!config) {
-        config = new Conf({ projectName: "zapier-sdk-cli" });
-    }
-    return config;
-}
-const ONE_DAY_MS = 24 * 60 * 60 * 1000;
-const CACHE_RESET_INTERVAL_MS = (() => {
-    const { ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS = `${ONE_DAY_MS}` } = process.env;
-    const interval = parseInt(ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS);
-    if (isNaN(interval) || interval < 0) {
-        return -1;
-    }
-    return interval;
-})();
-function getVersionCache() {
-    try {
-        const cache = getConfig().get("version_cache");
-        const now = Date.now();
-        // If no cache, missing timestamp, or it's been more than a day, reset the cache
-        if (!cache ||
-            !cache.last_reset_timestamp ||
-            now - cache.last_reset_timestamp >= CACHE_RESET_INTERVAL_MS) {
-            const newCache = {
-                last_reset_timestamp: now,
-                packages: {},
-            };
-            getConfig().set("version_cache", newCache);
-            return newCache;
-        }
-        return cache;
-    }
-    catch (error) {
-        log.debug(`Failed to read version cache: ${error}`);
-        return {
-            last_reset_timestamp: Date.now(),
-            packages: {},
-        };
-    }
-}
-function setCachedPackageInfo(packageName, version, info) {
-    try {
-        const cache = getVersionCache();
-        if (!cache.packages[packageName]) {
-            cache.packages[packageName] = {};
-        }
-        cache.packages[packageName][version] = info;
-        getConfig().set("version_cache", cache);
-    }
-    catch (error) {
-        log.debug(`Failed to cache package info: ${error}`);
-    }
-}
-function getCachedPackageInfo(packageName, version) {
-    try {
-        const cache = getVersionCache();
-        return cache.packages[packageName]?.[version];
-    }
-    catch (error) {
-        log.debug(`Failed to get cached package info: ${error}`);
-        return undefined;
-    }
-}
-async function fetchCachedPackageInfo(packageName, version) {
-    const cacheKey = version || "latest";
-    // Try cache first
-    let cachedInfo = getCachedPackageInfo(packageName, cacheKey);
-    if (cachedInfo) {
-        return cachedInfo;
-    }
-    // Not in cache, fetch from npm
-    const packageInfo = await packageJsonLib(packageName, {
-        version,
-        fullMetadata: true,
-    });
-    const info = {
-        version: packageInfo.version,
-        deprecated: packageInfo.deprecated,
-        fetched_at: new Date().toISOString(),
-    };
-    // Cache for next time
-    setCachedPackageInfo(packageName, cacheKey, info);
-    return info;
-}
-export async function checkForUpdates({ packageName, currentVersion, }) {
-    try {
-        // Get latest version info (with caching)
-        const latestPackageInfo = await fetchCachedPackageInfo(packageName);
-        const latestVersion = latestPackageInfo.version;
-        const hasUpdate = semver.gt(latestVersion, currentVersion);
-        // Check deprecation status of the current version (with caching)
-        let currentPackageInfo;
-        try {
-            currentPackageInfo = await fetchCachedPackageInfo(packageName, currentVersion);
-        }
-        catch (error) {
-            // If we can't fetch the current version info, use the latest version info
-            log.debug(`Failed to check deprecation for current version: ${error}`);
-            currentPackageInfo = latestPackageInfo;
-        }
-        const isDeprecated = Boolean(currentPackageInfo.deprecated);
-        const deprecationMessage = isDeprecated
-            ? String(currentPackageInfo.deprecated)
-            : undefined;
-        return {
-            hasUpdate,
-            latestVersion,
-            currentVersion,
-            isDeprecated,
-            deprecationMessage,
-        };
-    }
-    catch (error) {
-        // If we can't check for updates (network issues, etc.), fail silently
-        log.debug(`Failed to check for updates: ${error}`);
-        return {
-            hasUpdate: false,
-            currentVersion,
-            isDeprecated: false,
-        };
-    }
-}
-export function displayUpdateNotification(versionInfo, packageName) {
-    if (versionInfo.isDeprecated) {
-        console.error();
-        console.error(chalk.red.bold("⚠️  DEPRECATION WARNING") +
-            chalk.red(` - ${packageName} v${versionInfo.currentVersion} is deprecated.`));
-        if (versionInfo.deprecationMessage) {
-            console.error(chalk.red(`   ${versionInfo.deprecationMessage}`));
-        }
-        console.error(chalk.red(`   Please update to the latest version.`));
-        console.error();
-    }
-    // Use stderr so update notifications don't pollute stdout when piping JSON to jq
-    if (versionInfo.hasUpdate) {
-        console.error();
-        console.error(chalk.yellow.bold("📦 Update available!") +
-            chalk.yellow(` ${packageName} v${versionInfo.currentVersion} → v${versionInfo.latestVersion}`));
-        console.error(chalk.yellow(`   Run ${chalk.bold(getUpdateCommand(packageName))} to update.`));
-        console.error();
-    }
-}
-export async function checkAndNotifyUpdates({ packageName, currentVersion, }) {
-    if (CACHE_RESET_INTERVAL_MS < 0) {
-        return;
-    }
-    const versionInfo = await checkForUpdates({ packageName, currentVersion });
-    displayUpdateNotification(versionInfo, packageName);
-}