@cedarjs/cli 9.0.0-canary.1784 → 9.0.0-canary.3124

package/dist/commands/test/testHandler.js

@@ -0,0 +1,104 @@
+import { runBin } from "@cedarjs/cli-helpers/packageManager/exec";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
+import { ensurePosixPath } from "@cedarjs/project-config";
+import { errorTelemetry, timedTelemetry } from "@cedarjs/telemetry";
+import { getPaths } from "../../lib/index.js";
+import * as project from "../../lib/project.js";
+import { warnIfNonStandardDatasourceUrl } from "./datasourceWarning.js";
+import { assertSingleViteVersion } from "./viteVersionCheck.js";
+function hasStringMessage(value) {
+  return typeof value === "object" && value !== null && "message" in value && value.message === "string";
+}
+function getExitCode(value) {
+  if (!value || typeof value !== "object" || !("exitCode" in value) || typeof value.exitCode !== "number") {
+    return void 0;
+  }
+  return value.exitCode;
+}
+const handler = async ({
+  filter: filterParams = [],
+  dbPush = true,
+  force = false,
+  ...others
+}) => {
+  recordTelemetryAttributes({
+    command: "test",
+    dbPush
+  });
+  let watch = true;
+  const rwjsPaths = getPaths();
+  const forwardVitestFlags = Object.keys(others).flatMap((flagName) => {
+    if (["db-push", "force", "loadEnvFiles", "$0", "_"].includes(flagName)) {
+      return [];
+    }
+    const flag = flagName.length > 1 ? `--${flagName}` : `-${flagName}`;
+    const flagValue = others[flagName];
+    if (flagName === "watch") {
+      watch = flagValue === true;
+    } else if (flagName === "run" && flagValue) {
+      watch = false;
+    }
+    if (Array.isArray(flagValue)) {
+      return flagValue.flatMap((val) => [flag, val]);
+    }
+    return [flag, flagValue];
+  });
+  const sides = filterParams.filter(
+    (filterString) => project.workspaces().includes(filterString)
+  );
+  const vitestFilterArgs = [
+    ...filterParams.filter(
+      (filterString) => !project.workspaces().includes(filterString)
+    )
+  ];
+  const vitestArgs = [
+    ...vitestFilterArgs,
+    ...forwardVitestFlags,
+    "--passWithNoTests"
+  ].filter((flagOrValue) => flagOrValue !== null);
+  if (process.env.CI) {
+    vitestArgs.push("--run");
+  }
+  if (!others["config"]) {
+    sides.forEach((side) => vitestArgs.push("--project", side));
+    if (!sides.length) {
+      project.workspaces().forEach((side) => sides.push(side));
+    }
+  }
+  try {
+    const cacheDirDb = `file:${ensurePosixPath(
+      rwjsPaths.generated.base
+    )}/test.db`;
+    const DATABASE_URL = process.env.TEST_DATABASE_URL || cacheDirDb;
+    if (sides.includes("api") && !dbPush) {
+      process.env.SKIP_DB_PUSH = "1";
+    }
+    if (sides.includes("api")) {
+      await warnIfNonStandardDatasourceUrl({ force });
+    }
+    if (sides.includes("web")) {
+      assertSingleViteVersion();
+    }
+    const runCommand = async () => {
+      await runBin("vitest", vitestArgs, {
+        cwd: rwjsPaths.base,
+        stdio: "inherit",
+        env: { ...process.env, DATABASE_URL }
+      });
+    };
+    if (watch) {
+      await runCommand();
+    } else {
+      await timedTelemetry(process.argv, { type: "test" }, async () => {
+        await runCommand();
+      });
+    }
+  } catch (error) {
+    const message = hasStringMessage(error) ? error.message : "Test command failed";
+    errorTelemetry(process.argv, message);
+    process.exit(getExitCode(error) ?? 1);
+  }
+};
+export {
+  handler
+};

package/dist/commands/test/viteVersionCheck.js

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { getPaths } from "@cedarjs/project-config";
+function resolvePackage(fromFile, packageName) {
+  try {
+    const require2 = createRequire(fromFile);
+    const packageJsonPath = require2.resolve(`${packageName}/package.json`);
+    const packageJson = JSON.parse(
+      fs.readFileSync(packageJsonPath, "utf-8")
+    );
+    if (typeof packageJson !== "object" || packageJson === null || !("version" in packageJson) || typeof packageJson.version !== "string") {
+      return void 0;
+    }
+    return {
+      version: packageJson.version,
+      dir: path.dirname(packageJsonPath)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function resolveViteVersions({
+  projectBase,
+  webBase
+}) {
+  const vitest = resolvePackage(
+    path.join(projectBase, "package.json"),
+    "vitest"
+  );
+  const vitestVite = vitest ? resolvePackage(path.join(vitest.dir, "package.json"), "vite") : void 0;
+  const cedarVite = resolvePackage(
+    path.join(webBase, "package.json"),
+    "@cedarjs/vite"
+  );
+  const frameworkVite = cedarVite ? resolvePackage(path.join(cedarVite.dir, "package.json"), "vite") : void 0;
+  return { vitestVite, frameworkVite };
+}
+function getViteVersionMismatchMessage({
+  vitestVite,
+  frameworkVite
+}) {
+  if (!vitestVite || !frameworkVite) {
+    return void 0;
+  }
+  if (vitestVite.version === frameworkVite.version) {
+    return void 0;
+  }
+  return `Vitest is using Vite ${vitestVite.version} from
+  ${vitestVite.dir}
+but CedarJS is built against Vite ${frameworkVite.version} from
+  ${frameworkVite.dir}
+
+The CedarJS Vite plugins only work with the Vite version they're built against, so web tests can't run while Vitest uses a different copy. This happens when the project doesn't pin \`vite\`, because Vitest accepts a wide range of Vite versions and installs the newest one.
+
+Please add an override/resolution that pins vite to ${frameworkVite.version}, then reinstall your dependencies.`;
+}
+function assertSingleViteVersion() {
+  const cedarPaths = getPaths();
+  const message = getViteVersionMismatchMessage(
+    resolveViteVersions({
+      projectBase: cedarPaths.base,
+      webBase: cedarPaths.web.base
+    })
+  );
+  if (message) {
+    console.error(message);
+    process.exit(1);
+  }
+}
+export {
+  assertSingleViteVersion,
+  getViteVersionMismatchMessage,
+  resolveViteVersions
+};

package/dist/commands/test.js

@@ -1,39 +1,36 @@
 import { terminalLink } from "termi-link";
-import c from "../lib/colors.js";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
 import { workspaces } from "../lib/project.js";
 const command = "test [filter..]";
-const description = "Run Jest tests. Defaults to watch mode";
+const description = "Run Vitest tests. Defaults to watch mode";
 const builder = (yargs) => {
+  const cliDocsLink = terminalLink(
+    "CedarJS CLI Reference",
+    "https://cedarjs.com/docs/cli-commands#test"
+  );
+  const vitestTip = c.tip("yarn vitest --help");
   yargs.strict(false).positional("filter", {
     default: workspaces(),
     description: "Which side(s) to test, and/or a regular expression to match against your test files to filter by",
-    type: "array"
-  }).option("watch", {
-    describe: "Run tests related to changed files based on hg/git. Specify the name or path to a file to focus on a specific set of tests",
-    type: "boolean",
-    default: true
-  }).option("collect-coverage", {
-    describe: "Show test coverage summary and output info to coverage directory",
-    type: "boolean",
-    default: false
+    type: "string",
+    array: true
   }).option("db-push", {
     describe: "Syncs the test database with your Prisma schema without requiring a migration. It creates a test database if it doesn't already exist.",
     type: "boolean",
     default: true
+  }).option("force", {
+    describe: "Skip any confirmation prompts and run tests without interruption. Useful in CI or scripted environments.",
+    type: "boolean",
+    default: false
   }).epilogue(
-    `For all available flags, run jest cli directly ${c.tip(
-      "yarn jest --help"
-    )}
+    `For all available flags, run vitest cli directly ${vitestTip}
 
-Also see the ${terminalLink(
-      "CedarJS CLI Reference",
-      "https://cedarjs.com/docs/cli-commands#test"
-    )}
+Also see the ${cliDocsLink}
 `
   );
 };
 const handler = async (options) => {
-  const { handler: handler2 } = await import("./testHandler.js");
+  const { handler: handler2 } = await import("./test/testHandler.js");
   return handler2(options);
 };
 export {

package/dist/commands/type-check.js

@@ -7,7 +7,8 @@ const builder = (yargs) => {
   yargs.strict(false).positional("sides", {
     default: workspaces(),
     description: "Which side(s) to run a typecheck on",
-    type: "array"
+    type: "string",
+    array: true
   }).option("prisma", {
     type: "boolean",
     default: true,

package/dist/commands/type-checkHandler.js

@@ -1,25 +1,37 @@
-import path from "path";
+import path from "node:path";
 import concurrently from "concurrently";
-import execa from "execa";
 import { Listr } from "listr2";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { formatRunBinCommand } from "@cedarjs/cli-helpers/packageManager/display";
+import { runBin } from "@cedarjs/cli-helpers/packageManager/exec";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { generatePrismaClient } from "../lib/generatePrismaClient.js";
 import { getPaths } from "../lib/index.js";
-const handler = async ({ sides, verbose, prisma, generate }) => {
+const isConcurrentlyErrorArray = (value) => {
+  return Array.isArray(value);
+};
+const handler = async ({
+  sides,
+  verbose = false,
+  prisma = true,
+  generate = true
+}) => {
+  const selectedSides = (Array.isArray(sides) ? sides : []).filter(
+    (side) => typeof side === "string"
+  );
   recordTelemetryAttributes({
     command: "type-check",
-    sides: JSON.stringify(sides),
+    sides: JSON.stringify(selectedSides),
     verbose,
     prisma,
     generate
   });
   const typeCheck = async () => {
     let conclusiveExitCode = 0;
-    const tscForAllSides = sides.map((side) => {
+    const tscForAllSides = selectedSides.map((side) => {
       const projectDir = path.join(getPaths().base, side);
       return {
         cwd: projectDir,
-        command: `yarn tsc --noEmit --skipLibCheck`
+        command: formatRunBinCommand("tsc", ["--noEmit", "--skipLibCheck"])
       };
     });
     const { result } = concurrently(tscForAllSides, {
@@ -28,32 +40,27 @@ const handler = async ({ sides, verbose, prisma, generate }) => {
     });
     try {
       await result;
-    } catch (err) {
-      if (err.length) {
-        const exitCodes = err.map((e) => e?.exitCode).filter(Boolean);
+    } catch (error) {
+      if (isConcurrentlyErrorArray(error)) {
+        const exitCodes = error.map((entry) => entry.exitCode).filter((exitCode2) => Boolean(exitCode2));
         conclusiveExitCode = Math.max(...exitCodes);
       }
     }
     return conclusiveExitCode;
   };
   if (generate && prisma) {
-    await generatePrismaClient({
-      verbose
-    });
+    await generatePrismaClient({ verbose });
   }
   if (generate) {
     await new Listr(
       [
         {
           title: "Generating types",
-          task: () => execa("yarn rw-gen", {
-            shell: true,
-            stdio: verbose ? "inherit" : "ignore"
-          })
+          task: () => runBin("cedar-gen", [], { stdio: verbose ? "inherit" : "ignore" })
         }
       ],
       {
-        renderer: verbose && "verbose",
+        renderer: verbose ? "verbose" : "default",
         rendererOptions: { collapseSubtasks: false }
       }
     ).run();

package/dist/commands/upgrade/preUpgradeScripts.js

@@ -3,7 +3,8 @@ import { builtinModules } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import execa from "execa";
-import semver from "semver";
+import { tryParse } from "verkit";
+const MAIN_BRANCH_PRERELEASE_TAGS = ["canary"];
 function isExecaError(e) {
   return e instanceof Error && ("stdout" in e || "stderr" in e || "exitCode" in e);
 }
@@ -12,7 +13,7 @@ async function runPreUpgradeScripts(ctx, task, { verbose, force }) {
     return;
   }
   const version = typeof ctx.versionToUpgradeTo === "string" ? ctx.versionToUpgradeTo : void 0;
-  const parsed = semver.parse(version);
+  const parsed = version ? tryParse(version) : null;
   const baseUrl = "https://raw.githubusercontent.com/cedarjs/cedar/main/upgrade-scripts/";
   const manifestUrl = `${baseUrl}manifest.json`;
   let manifest = [];
@@ -33,8 +34,15 @@ async function runPreUpgradeScripts(ctx, task, { verbose, force }) {
   if (!Array.isArray(manifest) || manifest.length === 0) {
     return;
   }
+  const prereleaseTag = parsed?.prerelease?.[0];
+  const isMainBranchPrerelease = typeof prereleaseTag === "string" && MAIN_BRANCH_PRERELEASE_TAGS.includes(prereleaseTag);
   const checkLevels = [];
-  if (parsed && !parsed.prerelease.length) {
+  if (parsed && isMainBranchPrerelease) {
+    checkLevels.push({
+      id: "tag",
+      candidates: [`${prereleaseTag}.ts`, `${prereleaseTag}/index.ts`]
+    });
+  } else if (parsed) {
     checkLevels.push({
       id: "exact",
       candidates: [`${version}.ts`, `${version}/index.ts`]
@@ -50,14 +58,6 @@ async function runPreUpgradeScripts(ctx, task, { verbose, force }) {
       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) {

package/dist/commands/upgrade/upgrade.js

@@ -1,5 +1,6 @@
 import { terminalLink } from "termi-link";
-import c from "../../lib/colors.js";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { dedupeIsSupported } from "@cedarjs/cli-helpers/packageManager";
 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) => {
@@ -40,7 +41,8 @@ const builder = (yargs) => {
   }).option("dedupe", {
     description: "Skip dedupe check with --no-dedupe",
     type: "boolean",
-    default: true
+    default: true,
+    hidden: !dedupeIsSupported()
   }).option("yes", {
     alias: "y",
     describe: "Skip prompts and use defaults",