@sous-io/sous 0.2.37 → 1.0.2

package/src/commands/subscription/update.ts

@@ -1,216 +0,0 @@
-/**
- * `sous subscription update [ref]`.
- *
- * Moves the lockfile's pins to the newest versions their ranges allow. With no
- * reference it covers every subscription; a reference narrows it to one
- * repository, one namespace or one recipe:
- *
- *     sous subscription update
- *     sous subscription update sous-recipes
- *     sous subscription update workflow
- *     sous subscription update workflow/task-files
- *
- * Every trusted repository's index is fetched fresh first. A pin moves only
- * within the range its subscription (or the recipe depending on it) declares,
- * and dependencies move with the closure. Only the lockfile changes; the
- * subscriptions themselves are never edited. The whole change is printed as a
- * plan and asked about once, and the project is rebuilt afterwards.
- */
-
-import { Args, Flags } from "@oclif/core";
-import { BaseCommand } from "../../base-command.js";
-import { runProjectBuild } from "../../lib/build-service.js";
-import { ConfigError } from "../../lib/errors.js";
-import { subscriptionServiceFor } from "../../lib/repos/subscription-service.js";
-import { describeUpdateScope } from "../../lib/repos/update-plan.js";
-import { formatAskReport } from "../../lib/vars/ask.js";
-import { collectProvidedAnswers } from "../../lib/vars/index.js";
-import {
-  blankLine,
-  dryRunNotice,
-  footer,
-  heading,
-  indent,
-  log,
-  paragraph,
-  showCommandVars,
-  subheading,
-  warning,
-} from "../../utils/formatting.js";
-import { answerFlags, confirmationFlag } from "../../utils/flags.js";
-
-export default class SubscriptionUpdate extends BaseCommand {
-  static description =
-    "Move this project's pinned recipe versions to the newest ones their ranges allow";
-
-  /**
-   * The other spelling of the topic. It lives under a hidden topic, so it is
-   * typable everywhere without ever reaching the top-level listing.
-   */
-  static aliases = ["subscriptions:update"];
-
-  static examples = [
-    "<%= config.bin %> subscription update",
-    "<%= config.bin %> subscription update sous-recipes",
-    "<%= config.bin %> subscription update workflow/task-files",
-    "<%= config.bin %> subscription update --dry-run",
-    "<%= config.bin %> subscription update --yes",
-  ];
-
-  static args = {
-    ref: Args.string({
-      description:
-        "What to update: a repository, a namespace or a recipe. Leave it out to update everything",
-      required: false,
-    }),
-  };
-
-  static flags = {
-    ...BaseCommand.baseFlags,
-    // One flag answers both questions this command can ask: the plan, and the
-    // trust question for a repository a newer version needs.
-    yes: confirmationFlag({ extraAliases: ["trust"] }),
-    "accept-first": Flags.boolean({
-      description:
-        "When the reference matches several things, take the first one listed",
-      default: false,
-    }),
-    "dry-run": Flags.boolean({
-      description:
-        "Print what would change without writing anything or downloading any recipe",
-      default: false,
-    }),
-    "no-build": Flags.boolean({
-      description: "Change the lockfile without rebuilding the project",
-      default: false,
-    }),
-    ...answerFlags(),
-  };
-
-  async run(): Promise<void> {
-    const { args, flags } = await this.parse(SubscriptionUpdate);
-    const dryRun = flags["dry-run"];
-
-    showCommandVars({
-      Project: this.projectLabel,
-      Config: this.configContext.configPath,
-      Updating: args.ref ?? "every subscription",
-      "Dry Run": dryRun,
-    });
-
-    heading("Updating");
-
-    if (dryRun) {
-      dryRunNotice(
-        "The indexes are fetched so the plan is current; no recipe is downloaded and " +
-          "nothing in this project is written."
-      );
-    }
-
-    const service = subscriptionServiceFor({
-      configContext: this.configContext,
-      settings: this.settings,
-      shellEnv: this.shellEnv,
-    });
-
-    const provided = collectProvidedAnswers({
-      ...(flags.answer === undefined ? {} : { answer: flags.answer }),
-      ...(flags["answers-file"] === undefined ? {} : { answersFile: flags["answers-file"] }),
-    });
-
-    const outcome = await service.update({
-      ...(args.ref === undefined ? {} : { ref: args.ref }),
-      yes: flags.yes,
-      acceptFirst: flags["accept-first"],
-      answers: provided,
-      dryRun,
-    });
-
-    const scope = describeUpdateScope(outcome.scope);
-
-    if (outcome.nothingToUpdate) {
-      footer();
-      return;
-    }
-
-    if (dryRun) {
-      paragraph(
-        `Nothing was written. Run the same command without '--dry-run' to update ${scope}.`
-      );
-      footer();
-      return;
-    }
-
-    blankLine();
-    subheading("Lockfile");
-    blankLine();
-    if (outcome.diff.unchanged) {
-      paragraph("Nothing changed.");
-    } else {
-      for (const line of outcome.diff.lines) log(indent(line));
-    }
-
-    if (outcome.trusted.length > 0) {
-      blankLine();
-      paragraph(
-        `Repositories trusted along the way: ${outcome.trusted.join(", ")}. They are ` +
-          `now recorded in this project's config, and your colleagues inherit them.`
-      );
-    }
-
-    if (outcome.answers !== undefined) {
-      blankLine();
-      subheading("Variables");
-      for (const line of formatAskReport(outcome.answers)) {
-        log(line === "" ? "" : indent(line));
-      }
-    }
-
-    if (outcome.cycles.length > 0) {
-      warning(
-        `Some of these recipes co-subscribe to each other in a circle:\n` +
-          outcome.cycles.map((cycle) => `  ${cycle.join(" -> ")}`).join("\n") +
-          `\nThat is unusual but not broken, and the lockfile was updated.`
-      );
-    }
-
-    const rebuilding = !flags["no-build"] && !outcome.diff.unchanged;
-
-    blankLine();
-    paragraph(
-      `The lockfile now pins the newest versions the ranges allow for ${scope}. ` +
-        `This project's subscriptions are exactly as they were.` +
-        (rebuilding || outcome.diff.unchanged ? "" : " The project was not rebuilt.")
-    );
-
-    footer();
-
-    if (rebuilding) await this.rebuildProject();
-  }
-
-  /**
-   * Rebuilds the project now that the lockfile has moved, so the outputs match
-   * the new versions when this command returns. The config is reloaded first,
-   * because a repository trusted along the way was written into a managed layer.
-   * A build that fails leaves the update in place, because it is already
-   * written; the message says so.
-   */
-  private async rebuildProject(): Promise<void> {
-    await this.reloadDiscoveredConfig();
-
-    const succeeded = await runProjectBuild({
-      settings: this.settings,
-      configContext: this.configContext,
-      shellEnv: this.shellEnv,
-      heading: "Building the project",
-    });
-
-    if (!succeeded) {
-      throw new ConfigError(
-        `The lockfile was updated, but the build that followed it failed, so this ` +
-          `project's outputs may not match the new versions yet. The update itself is ` +
-          `recorded; fix what the build reported above and run 'sous build' again.`
-      );
-    }
-  }
-}

package/src/commands/update.ts

@@ -1,178 +0,0 @@
-/**
- * `sous update` moves sous itself to a newer (or a chosen) version, for the
- * global install, the project's own install, or both, through whichever
- * package manager owns each one (sous-io/sous#135).
- *
- *     sous update
- *     sous update --global
- *     sous update --major
- *     sous update --version 0.2.18
- *     sous update --dry-run
- *
- * It runs outside a project as readily as inside one, so it opts out of the
- * config requirement, as `sous init` does. `bin/run.js` never hands this
- * command to a project's own copy: updating the copy that was invoked is the
- * point. The flow itself lives in `lib/self-update/run.ts`; this class turns
- * the flags into its options and decides the exit code.
- */
-
-import path from "node:path";
-import { Flags } from "@oclif/core";
-import { BaseCommand } from "../base-command.js";
-import { SOUS_DIR_NAME, findConfigInSousDir } from "../lib/config-discovery.js";
-import { ConfigError, isConfigError } from "../lib/errors.js";
-import { CLI_ROOT } from "../lib/package-info.js";
-import { registryUrl, runSelfUpdate } from "../lib/self-update/run.js";
-import type { UpdateScope, VersionRequest } from "../lib/self-update/index.js";
-import { confirmationFlag } from "../utils/flags.js";
-import { footer, showCommandVars } from "../utils/formatting.js";
-
-export default class Update extends BaseCommand {
-  static description =
-    "Update sous itself, globally and in this project, through the package manager that installed each copy";
-
-  /** This command updates sous wherever it is installed; a project config is optional. */
-  static override requiresConfig = false;
-
-  /**
-   * A config this copy cannot load (one written for a newer sous, say) is the
-   * very thing an update may fix, so it is a warning here rather than a stop.
-   */
-  static override toleratesConfigErrors = true;
-
-  static examples = [
-    "<%= config.bin %> update",
-    "<%= config.bin %> update --global",
-    "<%= config.bin %> update --major",
-    "<%= config.bin %> update --version 0.2.18",
-    "<%= config.bin %> update --version next",
-    "<%= config.bin %> update --dry-run",
-  ];
-
-  static flags = {
-    ...BaseCommand.baseFlags,
-    major: Flags.boolean({
-      description: "Install the newest published version, whatever its major version",
-      default: false,
-      exclusive: ["version"],
-    }),
-    version: Flags.string({
-      description: "Install this version, the newest version in this range, or the version this dist-tag names",
-      exclusive: ["major"],
-    }),
-    prerelease: Flags.boolean({
-      description:
-        "Count prerelease versions as candidates; on by default when the installed version is a prerelease",
-      allowNo: true,
-      aliases: ["pre"],
-    }),
-    global: Flags.boolean({
-      description: "Update only the global install",
-      default: false,
-      exclusive: ["project"],
-    }),
-    project: Flags.boolean({
-      description: "Update only this project's own install",
-      default: false,
-      exclusive: ["global"],
-    }),
-    yes: confirmationFlag(),
-    "dry-run": Flags.boolean({
-      description: "Print every install's plan without installing anything",
-      default: false,
-    }),
-    "no-build": Flags.boolean({
-      description: "Update the project install without building the project afterwards",
-      default: false,
-    }),
-  };
-
-  async run(): Promise<void> {
-    const { flags } = await this.parse(Update);
-    const dryRun = flags["dry-run"];
-    const request: VersionRequest =
-      flags.version !== undefined
-        ? { kind: "spec", spec: flags.version }
-        : flags.major
-          ? { kind: "major" }
-          : { kind: "default" };
-    const only: UpdateScope | undefined = flags.global
-      ? "global"
-      : flags.project
-        ? "project"
-        : undefined;
-
-    showCommandVars({
-      Directory: this.configLocator.cwd,
-      Installs: only === undefined ? "global and project" : `${only} only`,
-      Version: describeRequest(request),
-      Prereleases:
-        flags.prerelease === undefined
-          ? "counted when the installed version is one"
-          : flags.prerelease
-            ? "counted"
-            : "not counted",
-      Registry: registryUrl(),
-      "Dry Run": dryRun,
-    });
-
-    const outcome = await runSelfUpdate({
-      cwd: this.configLocator.cwd,
-      ownRoot: CLI_ROOT,
-      request,
-      ...(flags.prerelease === undefined ? {} : { prerelease: flags.prerelease }),
-      ...(only === undefined ? {} : { only }),
-      dryRun,
-      yes: flags.yes,
-      interactive: this.interactive,
-      build: !flags["no-build"],
-      buildDirFor: (projectRoot) => this.buildDirFor(projectRoot),
-    });
-
-    footer();
-
-    if (outcome.failed) {
-      throw new ConfigError(
-        "Not every step of the update succeeded; the summary above lists what completed and what failed."
-      );
-    }
-  }
-
-  /**
-   * Where a build after a project update runs: the directory of the config
-   * discovery found, when it lies inside the project that was updated, and
-   * otherwise the project root when its own `.sous/` holds a primary config.
-   * A config this copy could not load counts as found: the new copy may
-   * understand it, and its build is where any real problem is reported.
-   * Undefined means the project has no sous config, so nothing is built.
-   */
-  private buildDirFor(projectRoot: string): string | undefined {
-    const found = this.hasConfig ? this.discovered.sousDir : this.rejectedConfig?.sousDir;
-    if (found !== undefined) {
-      const configDir = path.dirname(found);
-      const relative = path.relative(projectRoot, configDir);
-      if (!relative.startsWith("..") && !path.isAbsolute(relative)) return configDir;
-    }
-    return holdsPrimaryConfig(path.join(projectRoot, SOUS_DIR_NAME)) ? projectRoot : undefined;
-  }
-}
-
-/**
- * Whether a `.sous/` directory holds a primary config. Holding several is
- * still holding one: the build that follows reports that mistake itself.
- */
-function holdsPrimaryConfig(sousDir: string): boolean {
-  try {
-    return findConfigInSousDir(sousDir) !== null;
-  } catch (error) {
-    if (isConfigError(error)) return true;
-    throw error;
-  }
-}
-
-/** The version request, as the opening block says it. */
-function describeRequest(request: VersionRequest): string {
-  if (request.kind === "default") return "the newest in each install's major version";
-  if (request.kind === "major") return "the newest published, whatever its major version";
-  return request.spec;
-}