@cedarjs/cli 6.0.0-rc.312 → 6.0.0

package/dist/commands/generate/cell/templates/cellFragment.tsx.template

@@ -0,0 +1,43 @@
+import type { ${fragmentName} } from 'types/graphql'
+
+import type {
+  CellSuccessProps,<% if (afterQuery || isEmpty) { %>
+  DataObject,<% } %>
+} from '@cedarjs/web'
+
+// A parent Cell spreads this fragment by name in its own QUERY, and passes
+// the matching field down as the `${camelName}` prop - no import needed,
+// just render <${pascalName}Cell />:
+//
+//   query FindSomething($id: Int!) {
+//     something(id: $id) {
+//       id
+//       ...${fragmentName}
+//     }
+//   }
+//
+//   <${pascalName}Cell ${camelName}={something} />
+export const FRAGMENT = gql`
+  fragment ${fragmentName} on ${fragmentOnType} {
+    id
+  }
+`
+<% if (isEmpty) { %>
+export const isEmpty = (
+  data: DataObject,
+  { isDataEmpty }: { isDataEmpty: (data: DataObject) => boolean },
+) => {
+  return isDataEmpty(data)
+}
+<% } %><% if (afterQuery) { %>
+export const afterQuery = (data: DataObject): DataObject => {
+  return data
+}
+<% } %>
+export const Empty = () => <div>Empty</div>
+
+export const Success = ({
+  ${camelName},
+}: CellSuccessProps<{ ${camelName}: ${fragmentName} }>) => {
+  return <div>{JSON.stringify(${camelName})}</div>
+}

package/dist/commands/generate/cell/templates/storiesFragment.tsx.template

@@ -0,0 +1,23 @@
+import type { Meta, StoryObj } from '@storybook/react'
+
+import { Empty, Success } from './${pascalName}Cell'
+import { standard } from './${pascalName}Cell.mock'
+
+const meta: Meta = {
+  title: 'Cells/${pascalName}Cell',
+  tags: ['autodocs']
+}
+
+export default meta
+
+export const empty: StoryObj<typeof Empty> = {
+  render: () => {
+    return Empty ? <Empty /> : <></>
+  }
+}
+
+export const success: StoryObj<typeof Success> = {
+  render: (args) => {
+    return Success ? <Success {...standard()} {...args} /> : <></>
+  }
+}

package/dist/commands/generate/cell/templates/testFragment.js.template

@@ -0,0 +1,30 @@
+import { render } from '@cedarjs/testing/web'
+
+import { Empty, Success } from './${pascalName}Cell'
+import { standard } from './${pascalName}Cell.mock'
+
+// Generated boilerplate tests do not account for all circumstances
+// and can fail without adjustments, e.g. Float and DateTime types.
+//           Please refer to the RedwoodJS Testing Docs:
+//        https://cedarjs.com/docs/testing#testing-cells
+// https://cedarjs.com/docs/testing#jest-expect-type-considerations
+
+describe('${pascalName}Cell', () => {
+  it('renders Empty successfully', async () => {
+    expect(() => {
+      render(<Empty />)
+    }).not.toThrow()
+  })
+
+  // When you're ready to test the actual output of your component render
+  // you could test that, for example, certain text is present:
+  //
+  // 1. import { screen } from '@cedarjs/testing/web'
+  // 2. Add test: expect(screen.getByText('Hello, world')).toBeInTheDocument()
+
+  it('renders Success successfully', async () => {
+    expect(() => {
+      render(<Success ${camelName}={standard().${camelName}} />)
+    }).not.toThrow()
+  })
+})

package/dist/commands/lintPreflight.js

@@ -0,0 +1,133 @@
+import fs from "node:fs";
+import path from "node:path";
+import { colors } from "@cedarjs/cli-helpers";
+import { formatAddRootPackagesCommand } from "@cedarjs/cli-helpers/packageManager/display";
+import { getPaths } from "@cedarjs/project-config";
+const FLAT_CONFIG_FILENAMES = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  "eslint.config.mts",
+  "eslint.config.cts"
+];
+const LEGACY_CONFIG_FILENAMES = [
+  ".eslintrc",
+  ".eslintrc.js",
+  ".eslintrc.cjs",
+  ".eslintrc.mjs",
+  ".eslintrc.json",
+  ".eslintrc.yaml",
+  ".eslintrc.yml"
+];
+const MIGRATION_GUIDE_URL = "https://github.com/cedarjs/cedar/blob/main/packages/eslint-config/README.md#migrating-from-legacy-eslintrcjs-config";
+function findFlatConfig(base) {
+  return FLAT_CONFIG_FILENAMES.map(
+    (filename) => path.join(base, filename)
+  ).find((configPath) => fs.existsSync(configPath));
+}
+function readRootPackageJson(base) {
+  try {
+    const contents = fs.readFileSync(path.join(base, "package.json"), "utf-8");
+    const parsed = JSON.parse(contents);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function hasLegacyConfig(base, packageJson) {
+  const hasLegacyConfigFile = LEGACY_CONFIG_FILENAMES.some(
+    (filename) => fs.existsSync(path.join(base, filename))
+  );
+  return hasLegacyConfigFile || Boolean(packageJson?.["eslintConfig"]);
+}
+function listsEslintConfigPackage(packageJson) {
+  return ["dependencies", "devDependencies"].some((field) => {
+    const deps = packageJson[field];
+    return deps !== null && typeof deps === "object" && "@cedarjs/eslint-config" in deps;
+  });
+}
+async function formatAddConfigPackageCommand() {
+  let version = "";
+  try {
+    const packageJson = await import("../../package.json", { with: { type: "json" } });
+    version = "@" + packageJson.default.version;
+  } catch {
+  }
+  try {
+    return formatAddRootPackagesCommand(
+      ["@cedarjs/eslint-config" + version],
+      true
+    );
+  } catch {
+    return "yarn add -D @cedarjs/eslint-config" + version;
+  }
+}
+async function legacyConfigMessage(packageJson) {
+  const needsConfigPackage = !packageJson || !listsEslintConfigPackage(packageJson);
+  return [
+    colors.error("Cedar no longer supports ESLint's legacy config format"),
+    "",
+    "Support for `.eslintrc.*` and the `eslintConfig` field in package.json",
+    "was removed in v6. Create an `eslint.config.mjs` in your project root",
+    '(`eslint.config.js` if your project is ESM, i.e. has `"type": "module"`):',
+    "",
+    colors.tip("  import cedarConfig from '@cedarjs/eslint-config'"),
+    "",
+    colors.tip("  export default await cedarConfig()"),
+    "",
+    "Then delete your `.eslintrc.*` file and remove the `eslintConfig` field",
+    "from package.json, moving any custom rules you had into an extra config",
+    "object after `cedarConfig()`.",
+    ...needsConfigPackage ? [
+      "",
+      "You'll also need `@cedarjs/eslint-config` itself, which is no longer",
+      "installed for you:",
+      "",
+      colors.tip("  " + await formatAddConfigPackageCommand())
+    ] : [],
+    "",
+    "Full migration guide: " + colors.link(MIGRATION_GUIDE_URL)
+  ].join("\n");
+}
+async function missingConfigPackageMessage(flatConfigPath) {
+  return [
+    colors.error("Cannot find `@cedarjs/eslint-config`"),
+    "",
+    `Your ${path.basename(flatConfigPath)} uses \`@cedarjs/eslint-config\`, but`,
+    "the package isn't listed in your project's package.json. As of v6,",
+    "`@cedarjs/core` no longer depends on it, so projects have to declare it",
+    "themselves:",
+    "",
+    colors.tip("  " + await formatAddConfigPackageCommand()),
+    "",
+    colors.info(
+      "`@cedarjs/eslint-config` brings its own ESLint, so you do not need to add `eslint` separately."
+    )
+  ].join("\n");
+}
+async function getEslintSetupError() {
+  const base = getPaths().base;
+  const packageJson = readRootPackageJson(base);
+  const flatConfigPath = findFlatConfig(base);
+  if (!flatConfigPath) {
+    if (!hasLegacyConfig(base, packageJson)) {
+      return void 0;
+    }
+    return legacyConfigMessage(packageJson);
+  }
+  if (!packageJson || listsEslintConfigPackage(packageJson)) {
+    return void 0;
+  }
+  const flatConfig = fs.readFileSync(flatConfigPath, "utf-8");
+  if (!flatConfig.includes("@cedarjs/eslint-config")) {
+    return void 0;
+  }
+  return missingConfigPackageMessage(flatConfigPath);
+}
+export {
+  getEslintSetupError
+};

package/dist/commands/setup/uploads/uploadsHandler.js

@@ -83,7 +83,7 @@ const handler = async ({ force }) => {
           if (transformResult.error) {
             if (transformResult.error === "RW_CODEMOD_ERR_OLD_FORMAT") {
               throw new Error(
-                "It looks like your src/lib/db file is using the old format. Please update it as per the v8 upgrade guide: https://cedarjs.com/docs/upgrade-guides/v8#database-file-structure-change. And run again. \n\nYou can also manually modify your api/src/lib/db to include the prisma extension: https://cedarjs.com/docs/uploads/#attaching-the-prisma-extension"
+                "It looks like your src/lib/db file is using the old format. Please update it as per the v8 upgrade guide: https://cedarjs.com/docs/8.x/upgrade-guides/v8#database-file-structure-change. And run again. \n\nYou can also manually modify your api/src/lib/db to include the prisma extension: https://cedarjs.com/docs/uploads/#attaching-the-prisma-extension"
               );
             }
             throw new Error(

package/dist/commands/upgrade/preUpgradeScripts.js

@@ -4,6 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import execa from "execa";
 import semver from "semver";
+const MAIN_BRANCH_PRERELEASE_TAGS = ["canary"];
 function isExecaError(e) {
   return e instanceof Error && ("stdout" in e || "stderr" in e || "exitCode" in e);
 }
@@ -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/upgradeHandler.js

@@ -33,6 +33,7 @@ const handler = async (upgradeOptions) => {
   });
   let preUpgradeMessage = "";
   let preUpgradeError = "";
+  const notBlockedByPreUpgradeChecks = (ctx) => force || !ctx.preUpgradeError;
   const tasks = new Listr(
     [
       {
@@ -87,39 +88,46 @@ const handler = async (upgradeOptions) => {
       {
         title: "Updating your CedarJS version",
         task: (ctx) => updateCedarJSDepsForAllSides(ctx, { dryRun, verbose }),
-        enabled: (ctx) => !!ctx.versionToUpgradeTo && !ctx.preUpgradeError
+        enabled: (ctx) => !!ctx.versionToUpgradeTo && notBlockedByPreUpgradeChecks(ctx)
       },
       {
         title: "Updating other packages in your package.json(s)",
         task: (ctx) => updatePackageVersionsFromTemplate(ctx, { dryRun, verbose }),
-        enabled: (ctx) => String(ctx.versionToUpgradeTo).includes("canary") && !ctx.preUpgradeError
+        // Canary only. This forces the template's dependency versions onto the
+        // project and adds back any the project is missing, which resurrects
+        // packages people have deliberately removed — a project that moved off
+        // SQLite gets better-sqlite3 back, for example. That's too blunt for
+        // regular upgrades, but people running canary are already signed up
+        // for rougher edges.
+        // https://github.com/redwoodjs/redwood/pull/8855
+        enabled: (ctx) => String(ctx.versionToUpgradeTo).includes("canary") && notBlockedByPreUpgradeChecks(ctx)
       },
       {
         title: "Downloading yarn patches",
         task: (ctx) => downloadYarnPatches(ctx, { dryRun, verbose }),
-        enabled: (ctx) => String(ctx.versionToUpgradeTo).includes("canary") && !ctx.preUpgradeError
+        enabled: (ctx) => String(ctx.versionToUpgradeTo).includes("canary") && notBlockedByPreUpgradeChecks(ctx)
       },
       {
         title: "Removing CLI cache",
         task: () => removeCliCache({ dryRun, verbose }),
-        enabled: (ctx) => !ctx.preUpgradeError
+        enabled: (ctx) => notBlockedByPreUpgradeChecks(ctx)
       },
       {
         title: `Running ${getPackageManager()} ${install()}`,
         task: () => packageManagerInstall({ verbose }),
-        enabled: (ctx) => !ctx.preUpgradeError,
+        enabled: (ctx) => notBlockedByPreUpgradeChecks(ctx),
         skip: () => !!dryRun
       },
       {
         title: "Refreshing the Prisma client",
         task: (_ctx, task) => refreshPrismaClient(task, { verbose }),
-        enabled: (ctx) => !ctx.preUpgradeError,
+        enabled: (ctx) => notBlockedByPreUpgradeChecks(ctx),
         skip: () => !!dryRun
       },
       {
         title: "De-duplicating dependencies",
         skip: () => !!dryRun || !dedupe2,
-        enabled: (ctx) => dedupeIsSupported() && !ctx.preUpgradeError,
+        enabled: (ctx) => dedupeIsSupported() && notBlockedByPreUpgradeChecks(ctx),
         task: (_ctx, task) => dedupeDeps(task, { verbose })
       },
       {
@@ -303,6 +311,22 @@ function updateCedarJSDepsForAllSides(ctx, options) {
     })
   );
 }
+function mergeTemplateDependencies(field, templatePackageJson, localPackageJson, messages, { dryRun, verbose } = {}) {
+  const templateDeps = templatePackageJson[field];
+  if (!templateDeps) {
+    return;
+  }
+  for (const [depName, depVersion] of Object.entries(templateDeps)) {
+    if (depName.startsWith("@cedarjs/")) {
+      continue;
+    }
+    const localDeps = localPackageJson[field] ??= {};
+    if (verbose || dryRun) {
+      messages.push(` - ${depName}: ${localDeps[depName]} => ${depVersion}`);
+    }
+    localDeps[depName] = depVersion;
+  }
+}
 async function updatePackageVersionsFromTemplate(ctx, { dryRun, verbose }) {
   if (!ctx.versionToUpgradeTo) {
     throw new Error("Failed to upgrade");
@@ -338,30 +362,15 @@ async function updatePackageVersionsFromTemplate(ctx, { dryRun, verbose }) {
           const localPackageJsonText = fs.readFileSync(pkgJsonPath, "utf-8");
           const localPackageJson = JSON.parse(localPackageJsonText);
           const messages = [];
-          Object.entries(templatePackageJson.dependencies || {}).forEach(
-            ([depName, depVersion]) => {
-              if (!depName.startsWith("@cedarjs/")) {
-                if (verbose || dryRun) {
-                  messages.push(
-                    ` - ${depName}: ${localPackageJson.dependencies[depName]} => ${depVersion}`
-                  );
-                }
-                localPackageJson.dependencies[depName] = depVersion;
-              }
-            }
-          );
-          Object.entries(templatePackageJson.devDependencies || {}).forEach(
-            ([depName, depVersion]) => {
-              if (!depName.startsWith("@cedarjs/")) {
-                if (verbose || dryRun) {
-                  messages.push(
-                    ` - ${depName}: ${localPackageJson.devDependencies[depName]} => ${depVersion}`
-                  );
-                }
-                localPackageJson.devDependencies[depName] = depVersion;
-              }
-            }
-          );
+          for (const field of ["dependencies", "devDependencies"]) {
+            mergeTemplateDependencies(
+              field,
+              templatePackageJson,
+              localPackageJson,
+              messages,
+              { dryRun, verbose }
+            );
+          }
           if (messages.length > 0) {
             task.title = task.title + "\n" + messages.join("\n");
           }
@@ -469,5 +478,6 @@ async function dedupeDeps(_task, { verbose }) {
   await packageManagerInstall({ verbose });
 }
 export {
-  handler
+  handler,
+  mergeTemplateDependencies
 };

package/dist/lib/background.js

@@ -3,6 +3,23 @@ import fs from "node:fs";
 import os from "os";
 import path from "path";
 import { getPaths } from "@cedarjs/project-config";
+function quoteForWindowsShell(arg) {
+  let quoted = '"';
+  let backslashes = 0;
+  for (const char of arg) {
+    if (char === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (char === '"') {
+      quoted += "\\".repeat(backslashes * 2 + 1) + '"';
+    } else {
+      quoted += "\\".repeat(backslashes) + char;
+    }
+    backslashes = 0;
+  }
+  return quoted + "\\".repeat(backslashes * 2) + '"';
+}
 function spawnBackgroundProcess(name, cmd, args) {
   const logDirectory = path.join(getPaths().generated.base, "logs");
   fs.mkdirSync(logDirectory, { recursive: true });
@@ -37,7 +54,8 @@ function spawnBackgroundProcess(name, cmd, args) {
       shell: true,
       stdio: ["ignore", stdout, stderr]
     };
-    const child = spawn(cmd + " " + args.join(" "), spawnOptions);
+    const command = [cmd, ...args].map(quoteForWindowsShell).join(" ");
+    const child = spawn(command, spawnOptions);
     child.unref();
   } else {
     const spawnOptions = {
@@ -51,5 +69,6 @@ function spawnBackgroundProcess(name, cmd, args) {
   fs.closeSync(stderr);
 }
 export {
+  quoteForWindowsShell,
   spawnBackgroundProcess
 };