@reliverse/dler 2.3.3 → 2.3.4

package/dist/cmds/update/cmd.js

@@ -1,16 +1,21 @@
 import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
 import { logger } from "@reliverse/relinka";
 import { defineCommand, option } from "@reliverse/rempts-core";
 import { type } from "arktype";
 import { msgs } from "../../const.js";
 import {
-  checkPackageUpdatesForFile,
+  checkPackageUpdatesForAllFiles,
   handleInstallation,
   prepareAllUpdateCandidates,
   updatePackageJsonFileDirectly,
   validatePackageJson
 } from "./impl.js";
-import { displayStructuredUpdateResults } from "./utils.js";
+import {
+  displayStructuredUpdateResults,
+  initializeCache,
+  prepareDependenciesForUpdate
+} from "./utils.js";
 export default defineCommand({
   description: "Update all dependencies to their latest versions across all package.json files. Supports selective updates with glob patterns and comprehensive filtering options.",
   options: {
@@ -27,11 +32,13 @@ export default defineCommand({
       description: "Dependencies to exclude from updates, supports glob patterns (e.g. 'eslint-*', '@types/*')"
     }),
     dryRun: option(type("boolean | undefined"), {
+      short: "n",
       description: "Preview updates without making changes"
     }),
     install: option(type("boolean | undefined"), {
       description: "Run install after updating (default: true)",
-      short: "i"
+      short: "i",
+      default: true
     }),
     allowMajor: option(type("boolean | undefined"), {
       description: "Allow major version updates (default: true)"
@@ -42,6 +49,10 @@ export default defineCommand({
     }),
     ignoreFields: option(type("string | undefined"), {
       description: "Dependency fields to ignore (e.g., 'peerDependencies,catalog')"
+    }),
+    verbose: option(type("boolean | undefined"), {
+      description: "Verbose output (shows install command output)",
+      short: "v"
     })
   },
   handler: async ({ flags }) => {
@@ -51,48 +62,91 @@ export default defineCommand({
         process.exit(1);
       }
       const ci = flags.ci ?? (!process.stdout.isTTY || !!process.env.CI);
+      const cwd = flags.cwd;
       const dryRun = flags.dryRun ?? false;
-      const install = flags.install ?? true;
-      const allowMajor = flags.allowMajor ?? true;
+      const install = flags.install;
+      const allowMajor = true;
       const details = flags.details ?? false;
+      const verbose = flags.verbose ?? false;
       const isDryRun = dryRun;
       const shouldInstall = install;
       const showDetails = details;
+      const isVerbose = verbose;
       const fieldsToIgnore = flags.ignoreFields ? typeof flags.ignoreFields === "string" ? flags.ignoreFields.split(",").map((s) => s.trim()) : [] : [];
       await validatePackageJson();
-      const { packageJsonFiles, fileDepsMap } = await prepareAllUpdateCandidates();
+      await initializeCache(isVerbose);
+      let effectiveCwd = cwd;
+      if (!effectiveCwd) {
+        const currentDir = process.cwd();
+        const hasLocalPackageJson = await fs.pathExists(path.join(currentDir, "package.json"));
+        if (hasLocalPackageJson) {
+          effectiveCwd = ".";
+        }
+      }
+      const { packageJsonFiles, fileDepsMap } = await prepareAllUpdateCandidates(effectiveCwd);
       if (packageJsonFiles.length === 0) {
         logger.log("No package.json files found");
         return;
       }
-      let totalUpdated = 0;
-      const allResults = [];
+      const allUpdateResults = [];
+      const updateArgs = {
+        ci,
+        ...flags.name && {
+          name: typeof flags.name === "string" ? [flags.name] : flags.name
+        },
+        ...flags.ignore && {
+          ignore: typeof flags.ignore === "string" ? [flags.ignore] : flags.ignore
+        },
+        allowMajor,
+        dryRun: isDryRun,
+        install: shouldInstall,
+        ignoreFields: fieldsToIgnore,
+        concurrency: 50
+      };
       for (const packageJsonPath of packageJsonFiles) {
         const fileDeps = fileDepsMap.get(packageJsonPath);
-        if (!fileDeps) {
-          continue;
+        if (!fileDeps) continue;
+        const filteredDeps = prepareDependenciesForUpdate(fileDeps, {
+          name: updateArgs.name,
+          ignore: updateArgs.ignore,
+          ignoreFields: updateArgs.ignoreFields
+        });
+        if (filteredDeps.length === 0) continue;
+        const fileDepsMapForCheck = /* @__PURE__ */ new Map();
+        for (const depName of filteredDeps) {
+          const depInfo = fileDeps[depName];
+          if (depInfo) {
+            fileDepsMapForCheck.set(depName, {
+              versionSpec: depInfo.versionSpec,
+              locations: new Set(depInfo.locations),
+              files: /* @__PURE__ */ new Set([packageJsonPath])
+            });
+          }
         }
-        const updateArgs = {
-          ci,
-          ...flags.name && {
-            name: typeof flags.name === "string" ? [flags.name] : flags.name
-          },
-          ...flags.ignore && {
-            ignore: typeof flags.ignore === "string" ? [flags.ignore] : flags.ignore
-          },
-          allowMajor,
-          dryRun: isDryRun,
-          install: shouldInstall,
-          ignoreFields: fieldsToIgnore
-        };
-        const results = await checkPackageUpdatesForFile(fileDeps, updateArgs);
-        allResults.push(...results);
-        const toUpdate = results.filter((r) => r.updated && !r.error);
+        const filteredUpdateArgs = { ...updateArgs };
+        filteredUpdateArgs.name = void 0;
+        filteredUpdateArgs.ignore = void 0;
+        const fileResults2 = await checkPackageUpdatesForAllFiles(
+          fileDepsMapForCheck,
+          filteredUpdateArgs
+        );
+        allUpdateResults.push(...fileResults2);
+      }
+      const fileUpdatePromises = packageJsonFiles.map(async (packageJsonPath) => {
+        const fileDeps = fileDepsMap.get(packageJsonPath);
+        if (!fileDeps) return { results: [], updated: 0 };
+        const fileResults2 = allUpdateResults.filter((result) => {
+          return fileDeps[result.package] !== void 0;
+        });
+        const toUpdate = fileResults2.filter((r) => r.updated && !r.error);
         if (toUpdate.length > 0) {
           if (isDryRun) {
             const relativePath = path.relative(process.cwd(), packageJsonPath);
-            logger.debug(`Would update ${toUpdate.length} dependencies in ${relativePath}`);
-            continue;
+            const updateDetails = toUpdate.map((update) => `${update.package}\u2192${update.latestVersion}`).join(", ");
+            logger.log(
+              `Would update ${toUpdate.length} dependencies in ${relativePath}: ${updateDetails}`
+            );
+            return { results: fileResults2, updated: toUpdate.length };
           }
           const updated = await updatePackageJsonFileDirectly(
             packageJsonPath,
@@ -101,14 +155,32 @@ export default defineCommand({
             "^",
             fieldsToIgnore
           );
-          totalUpdated += updated;
           if (updated > 0) {
             const relativePath = path.relative(process.cwd(), packageJsonPath);
-            logger.debug(`Updated ${updated} dependencies in ${relativePath}`);
+            const updateDetails = toUpdate.map((update) => `${update.package}\u2192${update.latestVersion}`).join(", ");
+            logger.log(`Updated ${updated} dependencies in ${relativePath}: ${updateDetails}`);
           }
+          return { results: fileResults2, updated };
         }
+        return { results: fileResults2, updated: 0 };
+      });
+      const fileResults = await Promise.allSettled(fileUpdatePromises);
+      const processedFileResults = fileResults.map((result, index) => {
+        if (result.status === "fulfilled") {
+          return result.value;
+        } else {
+          const packageJsonPath = packageJsonFiles[index];
+          logger.warn(
+            `Failed to process ${packageJsonPath ? path.relative(process.cwd(), packageJsonPath) : `file at index ${index}`}: ${result.reason}`
+          );
+          return { results: [], updated: 0 };
+        }
+      });
+      let totalUpdated = 0;
+      for (const result of processedFileResults) {
+        totalUpdated += result.updated;
       }
-      displayStructuredUpdateResults(allResults, packageJsonFiles, fileDepsMap, showDetails);
+      displayStructuredUpdateResults(allUpdateResults, packageJsonFiles, fileDepsMap, showDetails);
       if (totalUpdated === 0) {
         if (isDryRun) {
           logger.log("Dry run mode - no changes would be made");
@@ -117,16 +189,21 @@ export default defineCommand({
         }
         return;
       }
+      const action = isDryRun ? "Would update" : "Updated";
       if (packageJsonFiles.length > 1) {
         logger.log(
-          `Updated ${totalUpdated} dependencies across ${packageJsonFiles.length} package.json files`
+          `${action} ${totalUpdated} dependencies across ${packageJsonFiles.length} package.json files`
         );
       } else {
-        logger.log(`Updated ${totalUpdated} dependencies`);
+        logger.log(`${action} ${totalUpdated} dependencies`);
       }
-      if (shouldInstall) {
-        await handleInstallation();
-      } else {
+      if (shouldInstall && totalUpdated > 0 && !isDryRun) {
+        await handleInstallation(isVerbose);
+      } else if (shouldInstall && totalUpdated === 0) {
+        logger.log("No dependencies were updated, skipping install");
+      } else if (shouldInstall && totalUpdated > 0 && isDryRun) {
+        logger.log("Dry run mode - no changes were made, skipping install");
+      } else if (!shouldInstall && totalUpdated > 0) {
         logger.log(
           "Run 'bun install' to apply the changes (use --no-install to skip automatic installation)"
         );

package/dist/cmds/update/impl.d.ts

@@ -9,13 +9,19 @@ interface UpdateArgs {
     allowMajor?: boolean;
     concurrency?: number;
     ignoreFields?: string[];
+    verbose?: boolean;
 }
 export declare function validatePackageJson(): Promise<string>;
-export declare function prepareAllUpdateCandidates(): Promise<{
+export declare function prepareAllUpdateCandidates(cwd?: string): Promise<{
     packageJsonFiles: string[];
     fileDepsMap: Map<string, Record<string, DependencyInfo>>;
 }>;
 export declare function checkPackageUpdatesForFile(fileDepsMap: Record<string, DependencyInfo>, args: UpdateArgs): Promise<UpdateResult[]>;
+export declare function checkPackageUpdatesForAllFiles(globalDepsMap: Map<string, {
+    versionSpec: string;
+    locations: Set<string>;
+    files: Set<string>;
+}>, args: UpdateArgs): Promise<UpdateResult[]>;
 export declare function updatePackageJsonFileDirectly(packageJsonPath: string, fileDepsMap: Record<string, DependencyInfo>, updatesToApply: UpdateResult[], savePrefix: string, fieldsToIgnore?: string[]): Promise<number>;
-export declare function handleInstallation(): Promise<void>;
+export declare function handleInstallation(verbose?: boolean): Promise<void>;
 export {};

package/dist/cmds/update/impl.js

@@ -8,6 +8,7 @@ import {
   checkPackageUpdate,
   collectTargetDependencies,
   prepareDependenciesForUpdate,
+  prepareDependenciesForUpdateFromMap,
   runInstallCommand
 } from "./utils.js";
 export async function validatePackageJson() {
@@ -18,9 +19,9 @@ export async function validatePackageJson() {
   }
   return packageJsonPath;
 }
-export async function prepareAllUpdateCandidates() {
+export async function prepareAllUpdateCandidates(cwd) {
   const glob = new Glob("**/package.json");
-  const packageJsonFiles = [];
+  let packageJsonFiles = [];
   for await (const file of glob.scan({
     cwd: process.cwd(),
     onlyFiles: true
@@ -30,24 +31,34 @@ export async function prepareAllUpdateCandidates() {
       packageJsonFiles.push(fullPath);
     }
   }
+  if (cwd) {
+    const cwdPath = path.resolve(process.cwd(), cwd);
+    packageJsonFiles = packageJsonFiles.filter((filePath) => {
+      return filePath.startsWith(cwdPath + path.sep) || filePath === path.join(cwdPath, "package.json");
+    });
+  }
   if (packageJsonFiles.length === 0) {
     logger.warn("No package.json files found");
     return { packageJsonFiles: [], fileDepsMap: /* @__PURE__ */ new Map() };
   }
-  logger.debug(`Found ${packageJsonFiles.length} package.json files`);
   const fileDepsMap = /* @__PURE__ */ new Map();
-  for (const packageJsonPath of packageJsonFiles) {
+  const readPromises = packageJsonFiles.map(async (packageJsonPath) => {
     try {
       const packageJson = JSON.parse(await fs.readFile(packageJsonPath, { encoding: "utf8" }));
       const { map } = collectTargetDependencies(packageJson);
-      fileDepsMap.set(packageJsonPath, map);
+      return { path: packageJsonPath, map };
     } catch (error) {
       logger.warn(
         `Failed to process ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
       );
+      return { path: packageJsonPath, map: {} };
     }
+  });
+  const readResults = await pMap(readPromises, (promise) => promise, { concurrency: 20 });
+  for (const result of readResults) {
+    fileDepsMap.set(result.path, result.map);
   }
-  logger.debug(`Processing ${packageJsonFiles.length} package.json files`);
+  logger.debug(`Processing ${packageJsonFiles.length} package.json files...`);
   return { packageJsonFiles, fileDepsMap };
 }
 export async function checkPackageUpdatesForFile(fileDepsMap, args) {
@@ -81,6 +92,56 @@ export async function checkPackageUpdatesForFile(fileDepsMap, args) {
     { concurrency: args.concurrency || 5 }
   );
 }
+export async function checkPackageUpdatesForAllFiles(globalDepsMap, args) {
+  const options = {
+    allowMajor: !!args.allowMajor,
+    savePrefix: "^",
+    // Use default prefix
+    concurrency: args.concurrency || 50
+    // Increased default concurrency for HTTP requests
+  };
+  const candidates = prepareDependenciesForUpdateFromMap(globalDepsMap, args);
+  if (candidates.length === 0) {
+    return [];
+  }
+  if (args.verbose) {
+    logger.debug(
+      `Checking ${candidates.length} unique dependencies across all files with concurrency ${options.concurrency}`
+    );
+  }
+  const promises = candidates.map(async (dep) => {
+    const depInfo = globalDepsMap.get(dep);
+    if (!depInfo?.versionSpec) {
+      return {
+        package: dep,
+        currentVersion: "unknown",
+        latestVersion: "unknown",
+        updated: false,
+        error: "Current version not found",
+        semverCompatible: false,
+        location: "unknown"
+      };
+    }
+    return checkPackageUpdate(dep, depInfo.versionSpec, depInfo.locations, options);
+  });
+  const results = await Promise.allSettled(promises);
+  return results.map((result, index) => {
+    if (result.status === "fulfilled") {
+      return result.value;
+    } else {
+      const dep = candidates[index] ?? "unknown";
+      return {
+        package: dep,
+        currentVersion: "unknown",
+        latestVersion: "unknown",
+        updated: false,
+        error: `Failed to check: ${result.reason}`,
+        semverCompatible: false,
+        location: "unknown"
+      };
+    }
+  });
+}
 export async function updatePackageJsonFileDirectly(packageJsonPath, fileDepsMap, updatesToApply, savePrefix, fieldsToIgnore = []) {
   if (updatesToApply.length === 0) {
     return 0;
@@ -127,9 +188,9 @@ export async function updatePackageJsonFileDirectly(packageJsonPath, fileDepsMap
     return 0;
   }
 }
-export async function handleInstallation() {
+export async function handleInstallation(verbose = false) {
   try {
-    await runInstallCommand();
+    await runInstallCommand(verbose);
     logger.log("Installation completed successfully");
   } catch (error) {
     logger.warn(`Install failed: ${error instanceof Error ? error.message : String(error)}`);

package/dist/cmds/update/utils.d.ts

@@ -48,6 +48,7 @@ export declare function isSemverCompatible(currentVersionRange: string, latestVe
 /**
  * Collect ALL dependencies from package.json.
  * Returns a map of dependency name to its version and all locations where it appears.
+ * Early filters out non-updateable dependencies to reduce processing.
  */
 export declare function collectTargetDependencies(pkg: PackageJsonWithCatalogs): {
     map: Record<string, DependencyInfo>;
@@ -61,9 +62,13 @@ export declare function applyVersionUpdate(pkg: PackageJsonWithCatalogs, depName
  */
 export declare function fetchVersionFromRegistry(packageName: string): Promise<string>;
 /**
- * Get latest version of a package
+ * Get latest version of a package with caching
  */
 export declare function getLatestVersion(packageName: string): Promise<string>;
+/**
+ * Initialize persistent cache (call this at the start of update operations)
+ */
+export declare function initializeCache(verbose?: boolean): Promise<void>;
 /**
  * Check if a package needs updating and get update information
  *
@@ -74,6 +79,18 @@ export declare function getLatestVersion(packageName: string): Promise<string>;
  * - When allowMajor=false: Only allows updates within semver range
  */
 export declare function checkPackageUpdate(packageName: string, versionSpec: string, locations: Set<string>, options: PackageCheckOptions): Promise<UpdateResult>;
+/**
+ * Filter and prepare dependencies for updating with glob pattern support (optimized for Map input)
+ */
+export declare function prepareDependenciesForUpdateFromMap(allDepsMap: Map<string, {
+    versionSpec: string;
+    locations: Set<string>;
+    files: Set<string>;
+}>, args: {
+    name?: string[];
+    ignore?: string[];
+    ignoreFields?: string[];
+}): string[];
 /**
  * Filter and prepare dependencies for updating with glob pattern support
  */
@@ -93,5 +110,5 @@ export declare function displayStructuredUpdateResults(results: UpdateResult[],
 /**
  * Run Bun install command
  */
-export declare function runInstallCommand(): Promise<void>;
+export declare function runInstallCommand(verbose?: boolean): Promise<void>;
 export {};