@cedarjs/cli 2.3.1-next.0 → 2.3.1-next.79

package/dist/commands/{buildHandler.js → build/buildHandler.js}

@@ -10,28 +10,37 @@ import { generate } from "@cedarjs/internal/dist/generate/generate";
 import { loadAndValidateSdls } from "@cedarjs/internal/dist/validateSchema";
 import { detectPrerenderRoutes } from "@cedarjs/prerender/detection";
 import { timedTelemetry } from "@cedarjs/telemetry";
-import { generatePrismaCommand } from "../lib/generatePrismaClient.js";
-import { getPaths, getConfig } from "../lib/index.js";
+import { generatePrismaCommand } from "../../lib/generatePrismaClient.js";
+import { getPaths, getConfig } from "../../lib/index.js";
+import { buildPackagesTask } from "./buildPackagesTask.js";
 const handler = async ({
-  side = ["api", "web"],
+  workspace = ["api", "web", "packages/*"],
   verbose = false,
   prisma = true,
-  prerender
+  prerender = true
 }) => {
   recordTelemetryAttributes({
     command: "build",
-    side: JSON.stringify(side),
+    workspace: JSON.stringify(workspace),
     verbose,
     prisma,
     prerender
   });
-  const rwjsPaths = getPaths();
-  const rwjsConfig = getConfig();
-  const useFragments = rwjsConfig.graphql?.fragments;
-  const useTrustedDocuments = rwjsConfig.graphql?.trustedDocuments;
-  const prismaSchemaExists = fs.existsSync(rwjsPaths.api.prismaConfig);
-  const prerenderRoutes = prerender && side.includes("web") ? detectPrerenderRoutes() : [];
-  const shouldGeneratePrismaClient = prisma && prismaSchemaExists && (side.includes("api") || prerenderRoutes.length > 0);
+  const cedarPaths = getPaths();
+  const cedarConfig = getConfig();
+  const useFragments = cedarConfig.graphql?.fragments;
+  const useTrustedDocuments = cedarConfig.graphql?.trustedDocuments;
+  const prismaSchemaExists = fs.existsSync(cedarPaths.api.prismaConfig);
+  const prerenderRoutes = prerender && workspace.includes("web") ? detectPrerenderRoutes() : [];
+  const shouldGeneratePrismaClient = prisma && prismaSchemaExists && (workspace.includes("api") || prerenderRoutes.length > 0);
+  const packageJsonPath = path.join(cedarPaths.base, "package.json");
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  const packageJsonWorkspaces = packageJson.workspaces;
+  const nonApiWebWorkspaces = Array.isArray(packageJsonWorkspaces) && packageJsonWorkspaces.length > 2 ? workspace.filter((w) => w !== "api" && w !== "web") : [];
+  const gqlFeaturesTaskTitle = `Generating types needed for ${[
+    useFragments && "GraphQL Fragments",
+    useTrustedDocuments && "Trusted Documents"
+  ].filter(Boolean).join(" and ")} support...`;
   const tasks = [
     shouldGeneratePrismaClient && {
       title: "Generating Prisma Client...",
@@ -39,28 +48,26 @@ const handler = async ({
         const { cmd, args } = await generatePrismaCommand();
         return execa(cmd, args, {
           stdio: verbose ? "inherit" : "pipe",
-          shell: true,
-          cwd: rwjsPaths.api.base
+          cwd: cedarPaths.api.base
         });
       }
     },
+    nonApiWebWorkspaces.length > 0 && {
+      title: "Building Packages...",
+      task: () => buildPackagesTask(nonApiWebWorkspaces)
+    },
     // If using GraphQL Fragments or Trusted Documents, then we need to use
-    // codegen to generate the types needed for possible types and the
-    // trusted document store hashes
+    // codegen to generate the types needed for possible types and the trusted
+    // document store hashes
     (useFragments || useTrustedDocuments) && {
-      title: `Generating types needed for ${[
-        useFragments && "GraphQL Fragments",
-        useTrustedDocuments && "Trusted Documents"
-      ].filter(Boolean).join(" and ")} support...`,
-      task: async () => {
-        await generate();
-      }
+      title: gqlFeaturesTaskTitle,
+      task: generate
     },
-    side.includes("api") && {
+    workspace.includes("api") && {
       title: "Verifying graphql schema...",
       task: loadAndValidateSdls
     },
-    side.includes("api") && {
+    workspace.includes("api") && {
       title: "Building API...",
       task: async () => {
         await cleanApiBuild();
@@ -73,22 +80,23 @@ const handler = async ({
         }
       }
     },
-    side.includes("web") && {
+    workspace.includes("web") && {
       title: "Building Web...",
       task: async () => {
         process.env.VITE_CJS_IGNORE_WARNING = "true";
         const createdRequire = createRequire(import.meta.url);
+        const buildBinPath = createdRequire.resolve(
+          "@cedarjs/vite/bins/rw-vite-build.mjs"
+        );
         await execa(
-          `node ${createdRequire.resolve(
-            "@cedarjs/vite/bins/rw-vite-build.mjs"
-          )} --webDir="${rwjsPaths.web.base}" --verbose=${verbose}`,
+          `node ${buildBinPath} --webDir="${cedarPaths.web.base}" --verbose=${verbose}`,
           {
             stdio: verbose ? "inherit" : "pipe",
             shell: true,
             // `cwd` is needed for yarn to find the rw-vite-build binary
             // It won't change process.cwd for anything else here, in this
             // process
-            cwd: rwjsPaths.web.base
+            cwd: cedarPaths.web.base
           }
         );
         if (!getConfig().experimental?.streamingSsr?.enabled) {
@@ -108,7 +116,7 @@ const handler = async ({
       console.log(
         `You have not marked any routes to "prerender" in your ${terminalLink(
           "Routes",
-          "file://" + rwjsPaths.web.routes
+          "file://" + cedarPaths.web.routes
         )}.`
       );
       return;
@@ -116,15 +124,15 @@ const handler = async ({
     await execa("yarn cedar prerender", {
       stdio: "inherit",
       shell: true,
-      cwd: rwjsPaths.web.base
+      cwd: cedarPaths.web.base
     });
   };
   const jobs = new Listr(tasks, {
-    renderer: verbose && "verbose"
+    renderer: verbose ? "verbose" : void 0
   });
   await timedTelemetry(process.argv, { type: "build" }, async () => {
     await jobs.run();
-    if (side.includes("web") && prerender && prismaSchemaExists) {
+    if (workspace.includes("web") && prerender && prismaSchemaExists) {
       await triggerPrerender();
     }
   });

package/dist/commands/build/buildPackagesTask.js

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import path from "node:path";
+import concurrently from "concurrently";
+import { importStatementPath } from "@cedarjs/project-config";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import { exitWithError } from "../../lib/exit.js";
+import { getPaths } from "../../lib/index.js";
+async function buildPackagesTask(nonApiWebWorkspaces) {
+  const cedarPaths = getPaths();
+  const globPattern = path.join(cedarPaths.packages, "*").replaceAll("\\", "/");
+  const workspacePaths = nonApiWebWorkspaces.some((w) => w === "packages/*") ? await Array.fromAsync(fs.promises.glob(globPattern)) : nonApiWebWorkspaces.map((w) => {
+    const workspacePath = path.join(
+      cedarPaths.packages,
+      w.split("/").at(-1)
+    );
+    if (!fs.existsSync(workspacePath)) {
+      throw new Error(`Workspace not found: ${workspacePath}`);
+    }
+    return importStatementPath(workspacePath);
+  });
+  const { result } = concurrently(
+    workspacePaths.map((workspacePath) => {
+      return {
+        command: `yarn build`,
+        name: workspacePath.split("/").at(-1),
+        cwd: workspacePath
+      };
+    }),
+    {
+      prefix: "{name} |",
+      timestampFormat: "HH:mm:ss"
+    }
+  );
+  await result.catch((e) => {
+    if (e?.message) {
+      errorTelemetry(
+        process.argv,
+        `Error concurrently building sides: ${e.message}`
+      );
+      exitWithError(e);
+    }
+  });
+}
+export {
+  buildPackagesTask
+};

package/dist/commands/build.js

@@ -1,16 +1,14 @@
 import { terminalLink } from "termi-link";
 import c from "../lib/colors.js";
 import { exitWithError } from "../lib/exit.js";
-import { sides } from "../lib/project.js";
+import { workspaces } from "../lib/project.js";
 import { checkNodeVersion } from "../middleware/checkNodeVersion.js";
-const command = "build [side..]";
+const command = "build [workspace..]";
 const description = "Build for production";
 const builder = (yargs) => {
-  const choices = sides();
-  yargs.positional("side", {
-    choices,
-    default: choices,
-    description: "Which side(s) to build",
+  yargs.positional("workspace", {
+    default: ["api", "web", "packages/*"],
+    description: "What workspace(s) to build. Valid values are: web, api, packages/*, <package-name>",
     type: "array"
   }).option("verbose", {
     alias: "v",
@@ -35,6 +33,22 @@ const builder = (yargs) => {
       message: `${c.error("Error")}: ${check.message}`,
       includeEpilogue: false
     });
+  }).check((argv) => {
+    const workspacesArg = argv.workspace;
+    if (!Array.isArray(workspacesArg)) {
+      return "Workspace must be an array";
+    }
+    const filtered = workspacesArg.filter(
+      (item) => item !== "api" && item !== "web" && item !== "packages/*"
+    );
+    if (filtered.length === 0) {
+      return true;
+    }
+    const workspaceNames = workspaces({ includePackages: true });
+    if (!workspacesArg.every((item) => workspaceNames.includes(item))) {
+      return c.error(`Unknown workspace(s) ${workspacesArg.join(" ")}`) + "\n\nValid values are: " + workspaceNames.join(", ");
+    }
+    return true;
   }).epilogue(
     `Also see the ${terminalLink(
       "CedarJS CLI Reference",
@@ -43,7 +57,7 @@ const builder = (yargs) => {
   );
 };
 const handler = async (options) => {
-  const { handler: handler2 } = await import("./buildHandler.js");
+  const { handler: handler2 } = await import("./build/buildHandler.js");
   return handler2(options);
 };
 export {

package/dist/commands/dev/apiDebugFlag.js

@@ -0,0 +1,18 @@
+import { argv } from "node:process";
+import { getConfig } from "@cedarjs/project-config";
+const defaultApiDebugPort = 18911;
+function getApiDebugFlag(apiDebugPort) {
+  if (apiDebugPort) {
+    return `--debug-port ${apiDebugPort}`;
+  } else if (argv.includes("--apiDebugPort")) {
+    return `--debug-port ${defaultApiDebugPort}`;
+  }
+  const apiDebugPortInConfig = getConfig().api.debugPort;
+  if (apiDebugPortInConfig) {
+    return `--debug-port ${apiDebugPortInConfig}`;
+  }
+  return "";
+}
+export {
+  getApiDebugFlag
+};

package/dist/commands/{devHandler.js → dev/devHandler.js}

@@ -1,30 +1,30 @@
 import fs from "node:fs";
 import path from "node:path";
-import { argv } from "node:process";
 import concurrently from "concurrently";
 import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
 import { shutdownPort } from "@cedarjs/internal/dist/dev";
 import { getConfig, getConfigPath } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import c from "../lib/colors.js";
-import { exitWithError } from "../lib/exit.js";
-import { generatePrismaClient } from "../lib/generatePrismaClient.js";
-import { getPaths } from "../lib/index.js";
-import { getFreePort } from "../lib/ports.js";
-import { serverFileExists } from "../lib/project.js";
-const defaultApiDebugPort = 18911;
+import c from "../../lib/colors.js";
+import { exitWithError } from "../../lib/exit.js";
+import { generatePrismaClient } from "../../lib/generatePrismaClient.js";
+import { getPaths } from "../../lib/index.js";
+import { getFreePort } from "../../lib/ports.js";
+import { serverFileExists } from "../../lib/project.js";
+import { getApiDebugFlag } from "./apiDebugFlag.js";
+import { getPackageWatchCommands } from "./packageWatchCommands.js";
 const handler = async ({
-  side = ["api", "web"],
+  workspace = ["api", "web", "packages/*"],
   forward = "",
   generate = true,
   apiDebugPort
 }) => {
   recordTelemetryAttributes({
     command: "dev",
-    side: JSON.stringify(side),
+    workspace: JSON.stringify(workspace),
     generate
   });
-  const rwjsPaths = getPaths();
+  const cedarPaths = getPaths();
   const serverFile = serverFileExists();
   const apiPreferredPort = parseInt(String(getConfig().api.port));
   let webPreferredPort = parseInt(
@@ -34,7 +34,7 @@ const handler = async ({
   let apiPortChangeNeeded = false;
   let webAvailablePort = webPreferredPort;
   let webPortChangeNeeded = false;
-  if (side.includes("api") && !serverFile) {
+  if (workspace.includes("api") && !serverFile) {
     apiAvailablePort = await getFreePort(apiPreferredPort);
     if (apiAvailablePort === -1) {
       exitWithError(void 0, {
@@ -43,7 +43,7 @@ const handler = async ({
     }
     apiPortChangeNeeded = apiAvailablePort !== apiPreferredPort;
   }
-  if (side.includes("web")) {
+  if (workspace.includes("web")) {
     const forwardedPortMatches = [
       ...forward.matchAll(/\-\-port(\=|\s)(?<port>[^\s]*)/g)
     ];
@@ -80,14 +80,14 @@ const handler = async ({
     ].filter(Boolean).join(" ");
     exitWithError(void 0, { message });
   }
-  if (side.includes("api")) {
+  if (workspace.includes("api")) {
     try {
       await generatePrismaClient({
         verbose: false,
         force: false
       });
     } catch (e) {
-      const message = e instanceof Object && "message" in e ? e.message : String(e);
+      const message = getErrorMessage(e);
       errorTelemetry(process.argv, `Error generating prisma client: ${message}`);
       console.error(c.error(message));
     }
@@ -95,7 +95,7 @@ const handler = async ({
       try {
         await shutdownPort(apiAvailablePort);
       } catch (e) {
-        const message = e instanceof Object && "message" in e ? e.message : String(e);
+        const message = getErrorMessage(e);
         errorTelemetry(process.argv, `Error shutting down "api": ${message}`);
         console.error(
           `Error whilst shutting down "api" port: ${c.error(message)}`
@@ -103,51 +103,41 @@ const handler = async ({
       }
     }
   }
-  if (side.includes("web")) {
+  if (workspace.includes("web")) {
     try {
       await shutdownPort(webAvailablePort);
     } catch (e) {
-      const message = e instanceof Object && "message" in e ? e.message : String(e);
+      const message = getErrorMessage(e);
       errorTelemetry(process.argv, `Error shutting down "web": ${message}`);
       console.error(
         `Error whilst shutting down "web" port: ${c.error(message)}`
       );
     }
   }
-  const getApiDebugFlag = () => {
-    if (apiDebugPort) {
-      return `--debug-port ${apiDebugPort}`;
-    } else if (argv.includes("--apiDebugPort")) {
-      return `--debug-port ${defaultApiDebugPort}`;
-    }
-    const apiDebugPortInToml = getConfig().api.debugPort;
-    if (apiDebugPortInToml) {
-      return `--debug-port ${apiDebugPortInToml}`;
-    }
-    return "";
-  };
-  const redwoodConfigPath = getConfigPath();
+  const cedarConfigPath = getConfigPath();
   const streamingSsrEnabled = getConfig().experimental?.streamingSsr?.enabled;
   process.env.VITE_CJS_IGNORE_WARNING = "true";
   let webCommand = `yarn cross-env NODE_ENV=development rw-vite-dev ${forward}`;
   if (streamingSsrEnabled) {
     webCommand = `yarn cross-env NODE_ENV=development rw-dev-fe ${forward}`;
   }
+  const rootPackageJsonPath = path.join(cedarPaths.base, "package.json");
   const rootPackageJson = JSON.parse(
-    fs.readFileSync(path.join(rwjsPaths.base, "package.json"), "utf8")
+    fs.readFileSync(rootPackageJsonPath, "utf8")
   );
   const isEsm = rootPackageJson.type === "module";
   const serverWatchCommand = isEsm ? `cedarjs-api-server-watch` : `rw-api-server-watch`;
-  const jobs = {
-    api: {
+  const jobs = [];
+  if (workspace.includes("api")) {
+    jobs.push({
       name: "api",
       command: [
         "yarn nodemon",
         "  --quiet",
-        `  --watch "${redwoodConfigPath}"`,
+        `  --watch "${cedarConfigPath}"`,
         `  --exec "yarn ${serverWatchCommand}`,
         `    --port ${apiAvailablePort}`,
-        `    ${getApiDebugFlag()}`,
+        `    ${getApiDebugFlag(apiDebugPort)}`,
         '    | rw-log-formatter"'
       ].join(" ").replace(/\s+/g, " "),
       env: {
@@ -155,45 +145,48 @@ const handler = async ({
         NODE_OPTIONS: getDevNodeOptions()
       },
       prefixColor: "cyan",
-      runWhen: () => fs.existsSync(rwjsPaths.api.src)
-    },
-    web: {
+      runWhen: () => fs.existsSync(cedarPaths.api.src)
+    });
+  }
+  if (workspace.includes("web")) {
+    jobs.push({
       name: "web",
       command: webCommand,
       prefixColor: "blue",
-      cwd: rwjsPaths.web.base,
-      runWhen: () => fs.existsSync(rwjsPaths.web.src)
-    },
-    gen: {
+      cwd: cedarPaths.web.base,
+      runWhen: () => fs.existsSync(cedarPaths.web.src)
+    });
+  }
+  if (generate) {
+    jobs.push({
       name: "gen",
       command: "yarn rw-gen-watch",
-      prefixColor: "green",
-      runWhen: () => generate
-    }
-  };
-  const mappedJobs = Object.keys(jobs).map((job) => {
-    if (side.includes(job) || job === "gen") {
-      return jobs[job];
+      prefixColor: "green"
+    });
+  }
+  const packageWorkspaces = workspace.filter(
+    (w) => w !== "api" && w !== "web" && w !== "gen"
+  );
+  if (packageWorkspaces.length > 0) {
+    const hasPackageJsonWorkspaces = Array.isArray(rootPackageJson.workspaces) && rootPackageJson.workspaces.some(
+      (workspace2) => workspace2.startsWith("packages/")
+    );
+    if (hasPackageJsonWorkspaces && fs.existsSync(cedarPaths.packages)) {
+      const pkgCommands = await getPackageWatchCommands(packageWorkspaces);
+      jobs.push(...pkgCommands);
     }
-    return {
-      name: "",
-      command: "",
-      runWhen: () => false
-    };
+  }
+  const filteredJobs = jobs.filter((job) => !job.runWhen || job.runWhen());
+  const { result } = concurrently(filteredJobs, {
+    prefix: "{name} |",
+    timestampFormat: "HH:mm:ss",
+    handleInput: true
   });
-  const { result } = concurrently(
-    mappedJobs.filter((job) => job.runWhen()),
-    {
-      prefix: "{name} |",
-      timestampFormat: "HH:mm:ss",
-      handleInput: true
-    }
-  );
   result.catch((e) => {
     if (e?.message) {
       errorTelemetry(
         process.argv,
-        `Error concurrently starting sides: ${e.message}`
+        `Error concurrently starting workspaces: ${e.message}`
       );
       exitWithError(e);
     }
@@ -210,6 +203,9 @@ function getDevNodeOptions() {
   }
   return `${NODE_OPTIONS} ${enableSourceMapsOption}`;
 }
+function getErrorMessage(error) {
+  return error instanceof Object && "message" in error ? error.message : String(error);
+}
 export {
   getDevNodeOptions,
   handler

package/dist/commands/dev/packageWatchCommands.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import path from "node:path";
+import { importStatementPath } from "@cedarjs/project-config";
+import c from "../../lib/colors.js";
+import { getPaths } from "../../lib/index.js";
+async function getPackageWatchCommands(packageWorkspaces) {
+  const cedarPaths = getPaths();
+  const globPattern = path.join(cedarPaths.packages, "*").replaceAll("\\", "/");
+  const workspacePaths = packageWorkspaces.some((w) => w === "packages/*") ? await Array.fromAsync(fs.promises.glob(globPattern)) : packageWorkspaces.map((w) => {
+    const packageFolderName = w.split("/").at(-1);
+    if (!packageFolderName) {
+      throw new Error(`Invalid package workspace: ${w}`);
+    }
+    const workspacePath = path.join(cedarPaths.packages, packageFolderName);
+    if (!fs.existsSync(workspacePath)) {
+      throw new Error(`Workspace not found: ${workspacePath}`);
+    }
+    return importStatementPath(workspacePath);
+  });
+  const watchablePackages = [];
+  const packagesWithoutWatch = [];
+  for (const workspacePath of workspacePaths) {
+    const packageJsonPath = path.join(workspacePath, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+      continue;
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    const packageName = workspacePath.split("/").at(-1);
+    if (packageJson.scripts?.watch) {
+      watchablePackages.push(workspacePath);
+    } else {
+      packagesWithoutWatch.push(packageName);
+    }
+  }
+  if (packagesWithoutWatch.length > 0) {
+    console.warn(
+      `${c.warning("Warning: ")} The following package(s) do not have a "watch" script and will be skipped: ` + packagesWithoutWatch.join(", ")
+    );
+  }
+  return watchablePackages.map((workspacePath) => {
+    const name = workspacePath.split("/").at(-1);
+    if (!name) {
+      throw new Error(`Invalid package path: ${workspacePath}`);
+    }
+    return {
+      name,
+      command: "yarn watch",
+      cwd: workspacePath
+    };
+  });
+}
+export {
+  getPackageWatchCommands
+};

package/dist/commands/dev.js

@@ -1,19 +1,21 @@
 import { terminalLink } from "termi-link";
 import c from "../lib/colors.js";
+import { workspaces } from "../lib/project.js";
 import { checkNodeVersion } from "../middleware/checkNodeVersion.js";
-const command = "dev [side..]";
-const description = "Start development servers for api, and web";
+const command = "dev [workspace..]";
+const description = "Start development servers for api, web, and packages";
 const builder = (yargs) => {
-  yargs.positional("side", {
-    choices: ["api", "web"],
-    default: ["api", "web"],
-    description: "Which dev server(s) to start",
+  yargs.positional("workspace", {
+    default: ["api", "web", "packages/*"],
+    description: "Which dev server(s) to start. Valid values: api, web, packages/*, <package-name>",
     type: "string",
     array: true
   }).option("forward", {
     alias: "fwd",
     description: 'String of one or more vite dev server config options, for example: `--fwd="--port=1234 --open=false"`',
     type: "string",
+    // The reason `forward` is hidden is that it's been broken with Vite and
+    // it's not clear how to fix it.
     hidden: true
   }).option("generate", {
     type: "boolean",
@@ -29,6 +31,22 @@ const builder = (yargs) => {
     }
     console.warn(`${c.warning("Warning")}: ${check.message}
 `);
+  }).check((argv) => {
+    const workspaceArg = argv.workspace;
+    if (!Array.isArray(workspaceArg)) {
+      return "Workspace must be an array";
+    }
+    const filtered = workspaceArg.filter(
+      (item) => item !== "api" && item !== "web" && item !== "packages/*"
+    );
+    if (filtered.length === 0) {
+      return true;
+    }
+    const workspaceNames = workspaces({ includePackages: true });
+    if (!filtered.every((item) => workspaceNames.includes(item))) {
+      return c.error(`Unknown workspace(s) ${filtered.join(" ")}`) + "\n\nValid values are: " + workspaceNames.join(", ");
+    }
+    return true;
   }).epilogue(
     `Also see the ${terminalLink(
       "CedarJS CLI Reference",
@@ -37,7 +55,7 @@ const builder = (yargs) => {
   );
 };
 const handler = async (options) => {
-  const { handler: handler2 } = await import("./devHandler.js");
+  const { handler: handler2 } = await import("./dev/devHandler.js");
   return handler2(options);
 };
 export {

package/dist/commands/generate/cell/cellHandler.js

@@ -22,7 +22,9 @@ const REDWOOD_WEB_PATH_NAME = "components";
 const files = async ({ name, typescript, ...argv }) => {
   let cellName = removeGeneratorName(name, "cell");
   let idName = "id";
-  let idType, mockIdValues = [42, 43, 44], model = null;
+  let idType;
+  let mockIdValues = [42, 43, 44];
+  let model = null;
   let templateNameSuffix = "";
   let typeName = cellName;
   const shouldGenerateList = (isWordPluralizable(cellName) ? isPlural(cellName) : argv.list) || argv.list;

package/dist/commands/generate/component/templates/test.tsx.template

@@ -2,7 +2,7 @@ import { render } from '@cedarjs/testing/web'
 
 import ${pascalName} from './${pascalName}'
 
-//   Improve this test with help from the Redwood Testing Doc:
+//   Improve this test with help from the CedarJS Testing Doc:
 //    https://cedarjs.com/docs/testing#testing-components
 
 describe('${pascalName}', () => {

package/dist/commands/generate/function/functionHandler.js

@@ -91,7 +91,7 @@ const handler = async ({ name, force, ...rest }) => {
       `Please consult the ${terminalLink(
         "Serverless Function Considerations",
         "https://cedarjs.com/docs/serverless-functions#security-considerations"
-      )} in the RedwoodJS documentation for more information.`
+      )} in the CedarJS documentation for more information.`
     );
     console.info("");
   } catch (e) {

package/dist/commands/generate/function/templates/function.ts.template

@@ -10,7 +10,7 @@ import { logger } from 'src/lib/logger'
  * is your responsibility to secure appropriately.
  *
  * @see {@link https://cedarjs.com/docs/serverless-functions#security-considerations|Serverless Function Considerations}
- * in the RedwoodJS documentation for more information.
+ * in the CedarJS documentation for more information.
  *<% if (!typescript) { %>
  * @typedef { import('aws-lambda').APIGatewayEvent } APIGatewayEvent
  * @typedef { import('aws-lambda').Context } Context<% } %>