@zapier/zapier-sdk-cli 0.13.16 → 0.14.1

package/src/utils/version-checker.ts

@@ -0,0 +1,236 @@
+import packageJsonLib from "package-json";
+import chalk from "chalk";
+import log from "./log";
+import Conf from "conf";
+import { getUpdateCommand } from "./package-manager-detector";
+
+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 = currentVersion !== latestVersion;
+
+    // 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);
+}