@cedarjs/cli 2.2.2-next.0 → 2.2.2-next.31

package/dist/commands/upgrade/preUpgradeScripts.js

@@ -0,0 +1,235 @@
+import fs from "node:fs";
+import { builtinModules } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import execa from "execa";
+import semver from "semver";
+function isExecaError(e) {
+  return e instanceof Error && ("stdout" in e || "stderr" in e || "exitCode" in e);
+}
+async function runPreUpgradeScripts(ctx, task, { verbose, force }) {
+  if (!ctx.versionToUpgradeTo) {
+    return;
+  }
+  const version = typeof ctx.versionToUpgradeTo === "string" ? ctx.versionToUpgradeTo : void 0;
+  const parsed = semver.parse(version);
+  const baseUrl = "https://raw.githubusercontent.com/cedarjs/cedar/main/upgrade-scripts/";
+  const manifestUrl = `${baseUrl}manifest.json`;
+  let manifest = [];
+  try {
+    const res = await fetch(manifestUrl);
+    if (res.status === 200) {
+      manifest = await res.json();
+    } else {
+      if (verbose) {
+        console.log("No upgrade script manifest found.");
+      }
+    }
+  } catch (e) {
+    if (verbose) {
+      console.log("Failed to fetch upgrade script manifest", e);
+    }
+  }
+  if (!Array.isArray(manifest) || manifest.length === 0) {
+    return;
+  }
+  const checkLevels = [];
+  if (parsed && !parsed.prerelease.length) {
+    checkLevels.push({
+      id: "exact",
+      candidates: [`${version}.ts`, `${version}/index.ts`]
+    });
+    checkLevels.push({
+      id: "patch",
+      candidates: [
+        `${parsed.major}.${parsed.minor}.x.ts`,
+        `${parsed.major}.${parsed.minor}.x/index.ts`
+      ]
+    });
+    checkLevels.push({
+      id: "minor",
+      candidates: [`${parsed.major}.x.ts`, `${parsed.major}.x/index.ts`]
+    });
+  } else if (parsed && parsed.prerelease.length > 0) {
+    checkLevels.push({
+      id: "tag",
+      candidates: [
+        `${parsed.prerelease[0]}.ts`,
+        `${parsed.prerelease[0]}/index.ts`
+      ]
+    });
+  }
+  const scriptsToRun = [];
+  for (const level of checkLevels) {
+    for (const candidate of level.candidates) {
+      if (manifest.includes(candidate)) {
+        scriptsToRun.push(candidate);
+        break;
+      }
+    }
+  }
+  if (scriptsToRun.length === 0) {
+    if (verbose) {
+      console.log(`No upgrade scripts found for ${version}`);
+    }
+    return;
+  }
+  ctx.preUpgradeMessage = "";
+  ctx.preUpgradeError = "";
+  for (const scriptName of scriptsToRun) {
+    task.output = `Found upgrade check script: ${scriptName}. Downloading...`;
+    const tempDir = await fs.promises.mkdtemp(
+      // realpath: https://github.com/e18e/ecosystem-issues/issues/168
+      path.join(fs.realpathSync(os.tmpdir()), "cedar-upgrade-")
+    );
+    const scriptPath = path.join(tempDir, "script.mts");
+    const isDirectoryScript = scriptName.includes("/");
+    if (isDirectoryScript) {
+      const dirName = scriptName.split("/")[0];
+      const githubApiUrl = `https://api.github.com/repos/cedarjs/cedar/contents/upgrade-scripts/${dirName}`;
+      try {
+        const dirRes = await fetch(githubApiUrl, {
+          headers: {
+            Accept: "application/vnd.github.v3+json"
+          }
+        });
+        if (dirRes.status !== 200) {
+          throw new Error(
+            `Failed to fetch directory contents: ${dirRes.statusText}`
+          );
+        }
+        const files = await dirRes.json();
+        for (const file of files) {
+          if (file.type === "file") {
+            task.output = `Downloading ${file.name}...`;
+            const fileRes = await fetch(file.download_url);
+            if (fileRes.status !== 200) {
+              throw new Error(`Failed to download ${file.name}`);
+            }
+            const fileContent = await fileRes.text();
+            const filePath = path.join(tempDir, file.name);
+            await fs.promises.writeFile(filePath, fileContent);
+            if (file.name === "index.ts") {
+              await fs.promises.rename(filePath, scriptPath);
+            }
+          }
+        }
+      } catch (e) {
+        if (verbose) {
+          console.error(e);
+        }
+        throw new Error(
+          `Failed to download upgrade script directory from ${githubApiUrl}`
+        );
+      }
+    } else {
+      const scriptUrl = `${baseUrl}${scriptName}`;
+      try {
+        const res = await fetch(scriptUrl);
+        if (res.status !== 200) {
+          throw new Error(`Failed to download script: ${res.statusText}`);
+        }
+        const scriptContent2 = await res.text();
+        await fs.promises.writeFile(scriptPath, scriptContent2);
+      } catch (e) {
+        if (verbose) {
+          console.error(e);
+        }
+        throw new Error(`Failed to download upgrade script from ${scriptUrl}`);
+      }
+    }
+    const scriptContent = await fs.promises.readFile(scriptPath, "utf8");
+    const deps = extractDependencies(scriptContent);
+    if (deps.length > 0) {
+      const depList = deps.join(", ");
+      task.output = `Installing dependencies for ${scriptName}: ${depList}...`;
+      await fs.promises.writeFile(
+        path.join(tempDir, "package.json"),
+        JSON.stringify({
+          name: "pre-upgrade-script",
+          version: "0.0.0",
+          dependencies: {}
+        })
+      );
+      await execa("npm", ["install", ...deps], { cwd: tempDir });
+    }
+    task.output = `Running pre-upgrade script: ${scriptName}...`;
+    let shouldCleanup = true;
+    try {
+      const { stdout } = await execa(
+        "node",
+        ["script.mts", "--verbose", String(verbose), "--force", String(force)],
+        { cwd: tempDir }
+      );
+      if (stdout) {
+        if (ctx.preUpgradeMessage) {
+          ctx.preUpgradeMessage += "\n";
+        }
+        ctx.preUpgradeMessage += `
+${stdout}`;
+      }
+    } catch (e) {
+      let errorOutput = String(e);
+      let exitCode;
+      let stderr;
+      if (isExecaError(e)) {
+        errorOutput = e.stdout || e.message;
+        stderr = e.stderr;
+        exitCode = e.exitCode;
+      } else if (e instanceof Error) {
+        errorOutput = e.message;
+      }
+      if (ctx.preUpgradeError) {
+        ctx.preUpgradeError += "\n";
+      }
+      if (verbose) {
+        ctx.preUpgradeError += `
+Pre-upgrade check ${scriptName} failed with exit code ${exitCode}:
+${stderr ? stderr + "\n" : ""}`;
+      }
+      ctx.preUpgradeError += `
+${errorOutput}`;
+      if (!force) {
+        await fs.promises.rm(tempDir, { recursive: true });
+        shouldCleanup = false;
+        return;
+      }
+    } finally {
+      if (shouldCleanup) {
+        await fs.promises.rm(tempDir, { recursive: true });
+      }
+    }
+  }
+}
+const extractDependencies = (content) => {
+  const deps = /* @__PURE__ */ new Map();
+  const commentRegex = /\/\/\s*@dependency:\s*(\S+)/g;
+  let match;
+  while ((match = commentRegex.exec(content)) !== null) {
+    const spec = match[1];
+    const nameMatch = spec.match(/^(@?[^@\s]+)(?:@.+)?$/);
+    if (nameMatch) {
+      deps.set(nameMatch[1], spec);
+    }
+  }
+  const importRegex = /(?:import|from)\s*\(?['"]([^'"]+)['"]\)?/g;
+  while ((match = importRegex.exec(content)) !== null) {
+    let name = match[1];
+    if (name.startsWith(".") || name.startsWith("/") || name.startsWith("node:") || builtinModules.includes(name)) {
+      continue;
+    }
+    const parts = name.split("/");
+    if (name.startsWith("@") && parts.length >= 2) {
+      name = parts.slice(0, 2).join("/");
+    } else if (parts.length >= 1) {
+      name = parts[0];
+    }
+    if (!deps.has(name)) {
+      deps.set(name, name);
+    }
+  }
+  return Array.from(deps.values());
+};
+export {
+  runPreUpgradeScripts
+};

package/dist/commands/upgrade/tags.js

@@ -0,0 +1,6 @@
+function isValidCedarJSTag(tag) {
+  return ["rc", "canary", "latest", "next", "experimental"].includes(tag);
+}
+export {
+  isValidCedarJSTag
+};

package/dist/commands/upgrade/upgrade.js

@@ -0,0 +1,75 @@
+import { terminalLink } from "termi-link";
+import c from "../../lib/colors.js";
+import { isValidCedarJSTag } from "./tags.js";
+const SEMVER_REGEX = /(?<=^v?|\sv?)(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|[\da-z-]*[a-z-][\da-z-]*)(?:\.(?:0|[1-9]\d*|[\da-z-]*[a-z-][\da-z-]*))*)?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?(?=$|\s)/i;
+const isValidSemver = (string) => {
+  return SEMVER_REGEX.test(string);
+};
+const validateTag = (tag) => {
+  const isTagValid = isValidSemver(tag) || isValidCedarJSTag(tag);
+  if (!isTagValid) {
+    throw new Error(
+      c.error(
+        "Invalid tag supplied. Supported values: 'rc', 'canary', 'latest', 'next', 'experimental', or a valid semver version\n"
+      )
+    );
+  }
+  return tag;
+};
+const command = "upgrade";
+const description = "Upgrade all @cedarjs packages via interactive CLI";
+const builder = (yargs) => {
+  yargs.example(
+    "cedar upgrade -t 0.20.1-canary.5",
+    "Specify a version. URL for Version History:\nhttps://www.npmjs.com/package/@cedarjs/core"
+  ).option("dry-run", {
+    alias: "d",
+    description: "Check for outdated packages without upgrading",
+    type: "boolean"
+  }).option("tag", {
+    alias: "t",
+    description: '[choices: "latest", "rc", "next", "canary", "experimental", or a specific-version (see example below)] WARNING: "canary", "rc" and "experimental" are unstable releases! And "canary" releases include breaking changes often requiring changes to your codebase when upgrading a project.',
+    requiresArg: true,
+    type: "string",
+    coerce: validateTag
+  }).option("verbose", {
+    alias: "v",
+    description: "Print verbose logs",
+    type: "boolean",
+    default: false
+  }).option("dedupe", {
+    description: "Skip dedupe check with --no-dedupe",
+    type: "boolean",
+    default: true
+  }).option("yes", {
+    alias: "y",
+    describe: "Skip prompts and use defaults",
+    default: false,
+    type: "boolean"
+  }).option("force", {
+    alias: "f",
+    describe: "Force upgrade even if pre-upgrade checks fail",
+    default: false,
+    type: "boolean"
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "CedarJS CLI Reference for the upgrade command",
+      "https://cedarjs.com/docs/cli-commands#upgrade"
+    )}.
+And the ${terminalLink(
+      "GitHub releases page",
+      "https://github.com/cedarjs/cedar/releases"
+    )} for more information on the current release.`
+  );
+};
+const handler = async (options) => {
+  const { handler: handler2 } = await import("./upgradeHandler.js");
+  return handler2(options);
+};
+export {
+  builder,
+  command,
+  description,
+  handler,
+  validateTag
+};