@zapier/zapier-sdk-cli 0.16.1 → 0.16.3

package/src/utils/schema-formatter.ts

@@ -1,153 +0,0 @@
-import chalk from "chalk";
-import type { z } from "zod";
-import util from "util";
-import type { FormattedItem, FormatMetadata } from "@zapier/zapier-sdk";
-// These functions are internal to SDK, implementing basic formatting fallback
-// TODO: Consider exposing these utilities or implementing proper CLI formatting
-
-function getFormatMetadata(schema: unknown): FormatMetadata | undefined {
-  return (schema as { _zod?: { def?: { formatMeta?: FormatMetadata } } })?._zod
-    ?.def?.formatMeta;
-}
-
-function getOutputSchema(schema: unknown): unknown {
-  return (schema as { _zod?: { def?: { outputSchema?: unknown } } })?._zod?.def
-    ?.outputSchema;
-}
-
-// ============================================================================
-// JSON Formatting
-// ============================================================================
-
-export function formatJsonOutput(data: unknown): void {
-  // 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: { inputSchema: z.ZodType; outputSchema?: z.ZodType },
-  items: unknown[],
-  startingNumber: number = 0,
-): void {
-  // 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: FormattedItem, itemNumber: number): void {
-  // 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: string, style: string): string {
-  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: unknown): FormattedItem {
-  const itemObj = item as {
-    title?: string;
-    name?: string;
-    key?: string;
-    id?: string;
-    description?: string;
-  };
-
-  return {
-    title: itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item",
-    id: itemObj.id,
-    key: itemObj.key,
-    description: itemObj.description,
-    details: [],
-  };
-}
-
-function formatItemsGeneric(
-  items: unknown[],
-  startingNumber: number = 0,
-): void {
-  // Convert generic items to FormattedItem and use formatSingleItem
-  items.forEach((item, index) => {
-    const formatted = convertGenericItemToFormattedItem(item);
-    formatSingleItem(formatted, startingNumber + index);
-  });
-}

package/src/utils/serializeAsync.ts

@@ -1,26 +0,0 @@
-import { createHash } from "node:crypto";
-
-const promises: Record<string, Promise<unknown>> = {};
-
-const serializeAsync =
-  <R, A extends []>(
-    fn: (...args: A) => Promise<R>,
-  ): ((...args: A) => Promise<R>) =>
-  async (...args: A): Promise<R> => {
-    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] as Promise<R>;
-  };
-
-export default serializeAsync;

package/src/utils/spinner.ts

@@ -1,23 +0,0 @@
-import ora from "ora";
-import { ZapierCliUserCancellationError } from "./errors";
-
-export const spinPromise = async <T>(
-  promise: Promise<T>,
-  text: string,
-): Promise<T> => {
-  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/src/utils/version-checker.test.ts

@@ -1,239 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { checkForUpdates, displayUpdateNotification } from "./version-checker";
-
-// Mock package-json
-vi.mock("package-json", () => ({
-  default: vi.fn(),
-}));
-
-// Mock chalk to make testing easier
-vi.mock("chalk", () => ({
-  default: {
-    red: Object.assign((text: string) => text, {
-      bold: (text: string) => text,
-    }),
-    yellow: Object.assign((text: string) => text, {
-      bold: (text: string) => text,
-    }),
-    bold: (text: string) => text,
-  },
-}));
-
-// Mock log module
-vi.mock("./log", () => ({
-  default: {
-    debug: vi.fn(),
-  },
-}));
-
-// Mock conf module
-const mockConf = {
-  get: vi.fn(),
-  set: vi.fn(),
-};
-vi.mock("conf", () => ({
-  default: vi.fn().mockImplementation(() => mockConf),
-}));
-
-const mockPackageJson = vi.mocked(await import("package-json")).default;
-
-describe("version-checker", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Ensure cache is cleared between tests by returning undefined from get
-    mockConf.get.mockReturnValue(undefined);
-    // Suppress console output during tests
-    vi.spyOn(console, "log").mockImplementation(() => {});
-    vi.spyOn(console, "error").mockImplementation(() => {});
-  });
-
-  describe("checkForUpdates", () => {
-    it("should detect when an update is available", async () => {
-      mockPackageJson.mockResolvedValue({
-        version: "1.0.1",
-        deprecated: false,
-      });
-
-      const result = await checkForUpdates({
-        packageName: "test-package",
-        currentVersion: "1.0.0",
-      });
-
-      expect(result).toEqual({
-        hasUpdate: true,
-        latestVersion: "1.0.1",
-        currentVersion: "1.0.0",
-        isDeprecated: false,
-        deprecationMessage: undefined,
-      });
-    });
-
-    it("should not suggest update when current version is newer than latest", async () => {
-      mockPackageJson.mockResolvedValue({
-        version: "1.0.0",
-        deprecated: false,
-      });
-
-      const result = await checkForUpdates({
-        packageName: "test-package",
-        currentVersion: "1.0.1",
-      });
-
-      expect(result).toEqual({
-        hasUpdate: false,
-        latestVersion: "1.0.0",
-        currentVersion: "1.0.1",
-        isDeprecated: false,
-        deprecationMessage: undefined,
-      });
-    });
-
-    it("should handle pre-release versions correctly", async () => {
-      mockPackageJson.mockResolvedValue({
-        version: "1.0.0-beta.2",
-        deprecated: false,
-      });
-
-      const result = await checkForUpdates({
-        packageName: "test-package",
-        currentVersion: "1.0.0-beta.1",
-      });
-
-      expect(result).toEqual({
-        hasUpdate: true,
-        latestVersion: "1.0.0-beta.2",
-        currentVersion: "1.0.0-beta.1",
-        isDeprecated: false,
-        deprecationMessage: undefined,
-      });
-    });
-
-    it("should detect when package is deprecated", async () => {
-      mockPackageJson.mockResolvedValue({
-        version: "1.0.0",
-        deprecated: "This package is no longer maintained",
-      });
-
-      const result = await checkForUpdates({
-        packageName: "test-package",
-        currentVersion: "1.0.0",
-      });
-
-      expect(result).toEqual({
-        hasUpdate: false,
-        latestVersion: "1.0.0",
-        currentVersion: "1.0.0",
-        isDeprecated: true,
-        deprecationMessage: "This package is no longer maintained",
-      });
-    });
-
-    it("should handle when no update is available", async () => {
-      mockPackageJson.mockResolvedValue({
-        version: "1.0.0",
-        deprecated: false,
-      });
-
-      const result = await checkForUpdates({
-        packageName: "test-package",
-        currentVersion: "1.0.0",
-      });
-
-      expect(result).toEqual({
-        hasUpdate: false,
-        latestVersion: "1.0.0",
-        currentVersion: "1.0.0",
-        isDeprecated: false,
-        deprecationMessage: undefined,
-      });
-    });
-
-    it("should handle network errors gracefully", async () => {
-      mockPackageJson.mockRejectedValue(new Error("Network error"));
-
-      const result = await checkForUpdates({
-        packageName: "test-package",
-        currentVersion: "1.0.0",
-      });
-
-      expect(result).toEqual({
-        hasUpdate: false,
-        currentVersion: "1.0.0",
-        isDeprecated: false,
-      });
-    });
-  });
-
-  describe("displayUpdateNotification", () => {
-    it("should display deprecation warning", () => {
-      const consoleSpy = vi
-        .spyOn(console, "error")
-        .mockImplementation(() => {});
-
-      displayUpdateNotification(
-        {
-          hasUpdate: false,
-          currentVersion: "1.0.0",
-          isDeprecated: true,
-          deprecationMessage: "This package is deprecated",
-        },
-        "test-package",
-      );
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining("DEPRECATION WARNING"),
-      );
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining("This package is deprecated"),
-      );
-    });
-
-    it("should display update notification", () => {
-      const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-
-      displayUpdateNotification(
-        {
-          hasUpdate: true,
-          currentVersion: "1.0.0",
-          latestVersion: "1.0.1",
-          isDeprecated: false,
-        },
-        "test-package",
-      );
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining("Update available!"),
-      );
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining("pnpm update test-package"),
-      );
-    });
-
-    it("should display both deprecation and update notifications", () => {
-      const consoleErrorSpy = vi
-        .spyOn(console, "error")
-        .mockImplementation(() => {});
-      const consoleLogSpy = vi
-        .spyOn(console, "log")
-        .mockImplementation(() => {});
-
-      displayUpdateNotification(
-        {
-          hasUpdate: true,
-          currentVersion: "1.0.0",
-          latestVersion: "1.0.1",
-          isDeprecated: true,
-          deprecationMessage: "This package is deprecated",
-        },
-        "test-package",
-      );
-
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining("DEPRECATION WARNING"),
-      );
-      expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("Update available!"),
-      );
-    });
-  });
-});

package/src/utils/version-checker.ts

@@ -1,237 +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";
-
-interface VersionInfo {
-  hasUpdate: boolean;
-  latestVersion?: string;
-  currentVersion: string;
-  isDeprecated: boolean;
-  deprecationMessage?: string;
-}
-
-interface CachedPackageInfo {
-  version: string;
-  deprecated?: string | boolean;
-  fetched_at: string; // ISO date string
-}
-
-interface VersionCache {
-  last_reset_timestamp: number; // Unix timestamp in milliseconds
-  packages: {
-    [packageName: string]: {
-      [version: string]: CachedPackageInfo;
-    };
-  };
-}
-
-let config: Conf | null = null;
-
-function getConfig(): Conf {
-  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(): VersionCache {
-  try {
-    const cache = getConfig().get("version_cache") as VersionCache | undefined;
-    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: VersionCache = {
-        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: string,
-  version: string,
-  info: CachedPackageInfo,
-): void {
-  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: string,
-  version: string,
-): CachedPackageInfo | undefined {
-  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: string,
-  version?: string,
-): Promise<CachedPackageInfo> {
-  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: CachedPackageInfo = {
-    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,
-}: {
-  packageName: string;
-  currentVersion: string;
-}): Promise<VersionInfo> {
-  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: CachedPackageInfo;
-    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: VersionInfo,
-  packageName: string,
-): void {
-  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();
-  }
-
-  if (versionInfo.hasUpdate) {
-    console.log();
-    console.log(
-      chalk.yellow.bold("📦 Update available!") +
-        chalk.yellow(
-          ` ${packageName} v${versionInfo.currentVersion} → v${versionInfo.latestVersion}`,
-        ),
-    );
-    console.log(
-      chalk.yellow(
-        `   Run ${chalk.bold(getUpdateCommand(packageName))} to update.`,
-      ),
-    );
-    console.log();
-  }
-}
-
-export async function checkAndNotifyUpdates({
-  packageName,
-  currentVersion,
-}: {
-  packageName: string;
-  currentVersion: string;
-}): Promise<void> {
-  if (CACHE_RESET_INTERVAL_MS < 0) {
-    return;
-  }
-  const versionInfo = await checkForUpdates({ packageName, currentVersion });
-  displayUpdateNotification(versionInfo, packageName);
-}

package/tsconfig.build.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "esnext",
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "bundler"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["dist", "node_modules", "src/**/*.test.ts", "src/**/*.spec.ts"]
-}