@cedarjs/cli 7.1.0 → 7.1.1-next.469

package/dist/commands/generate/service/serviceHandler.js

@@ -3,7 +3,14 @@ import camelcase from "camelcase";
 import { pluralize, singularize } from "@cedarjs/utils/cedarPluralize";
 import { transformTSToJS } from "../../../lib/index.js";
 import { getSchema, verifyModelName } from "../../../lib/schemaHelpers.js";
-import { redactedModelFields, relationsForModel } from "../helpers.js";
+import {
+  DEFAULT_IGNORE_FIELDS_FOR_INPUT,
+  nullableJsonFieldsInInput,
+  nullableRelationsForModel,
+  redactedModelFields,
+  relationsForModel,
+  requiredFieldsInUpdateInput
+} from "../helpers.js";
 import { createHandler, templateForFile } from "../yargsHandlerHelpers.js";
 function isServiceModel(schema) {
   return typeof schema === "object" && schema !== null && "fields" in schema && "name" in schema;
@@ -59,11 +66,13 @@ function scenarioFieldValue(field) {
       return randInt;
     case "Json":
       return { foo: "bar" };
-    case "String":
+    case "String": {
+      const isUnique = field.isUnique || field.isId;
       if (field.name?.toLowerCase().includes("email")) {
-        return field.isUnique ? `foo${randInt}@bar.com` : "foo@bar.com";
+        return isUnique ? `foo${randInt}@bar.com` : "foo@bar.com";
       }
-      return field.isUnique ? `String${randInt}` : "String";
+      return isUnique ? `String${randInt}` : "String";
+    }
     case "Bytes":
       return `new Uint8Array([${randIntArray}])`;
     default: {
@@ -152,11 +161,14 @@ const fieldsToInput = async (model) => {
   const modelName = camelcase(singularize(model));
   const inputObj = {};
   if (scalarFields.some(
-    (field) => redactedFields.includes(field.name)
+    (field) => redactedFields.includes(field.name) || DEFAULT_IGNORE_FIELDS_FOR_INPUT.includes(field.name) && !field.isUpdatedAt
   )) {
     return false;
   }
   scalarFields.forEach((field) => {
+    if (DEFAULT_IGNORE_FIELDS_FOR_INPUT.includes(field.name)) {
+      return;
+    }
     if (foreignKeys.includes(field.name)) {
       inputObj[field.name] = `scenario.${modelName}.two.${field.name}`;
     } else {
@@ -174,7 +186,7 @@ const fieldsToUpdate = async (model) => {
   const modelName = camelcase(singularize(model));
   let field, newValue, fieldName;
   const updatableFields = scalarFields.filter(
-    (scalar) => !redactedFields.includes(scalar.name)
+    (scalar) => !redactedFields.includes(scalar.name) && !DEFAULT_IGNORE_FIELDS_FOR_INPUT.includes(scalar.name)
   );
   field = updatableFields.find(
     (scalar) => !foreignKeys.includes(scalar.name)
@@ -250,6 +262,10 @@ const getIdName = async (model) => {
   if (!isServiceModel(schemaResult)) {
     return void 0;
   }
+  if (schemaResult.primaryKey?.fields.length) {
+    const { fields, name } = schemaResult.primaryKey;
+    return { fields, whereArg: name || fields.join("_") };
+  }
   return schemaResult.fields.find((field) => field.isId)?.name;
 };
 const files = async ({
@@ -262,15 +278,26 @@ const files = async ({
   const componentName = camelcase(pluralize(name));
   const model = name;
   const idName = await getIdName(model);
+  if (tests && rest.crud && idName !== void 0 && typeof idName !== "string") {
+    throw new Error(
+      `Cannot generate CRUD tests for "${model}": it has a compound primary key (@@id([${idName.fields.join(", ")}])), which isn't supported by the generated test file yet. Re-run with \`--tests=false\`.`
+    );
+  }
   const prismaImportSource = "src/lib/db";
   let modelRelations;
+  let updateInputRequiredFields = [];
+  let nullableJsonFields = [];
+  let nullableRelations = [];
+  const schemaResult = await getSchema(model);
+  if (isServiceModel(schemaResult)) {
+    updateInputRequiredFields = requiredFieldsInUpdateInput(schemaResult);
+    nullableJsonFields = nullableJsonFieldsInInput(schemaResult);
+    nullableRelations = nullableRelationsForModel(schemaResult);
+  }
   if (relations) {
     modelRelations = relations;
-  } else {
-    const schemaResult = await getSchema(model);
-    if (isServiceModel(schemaResult)) {
-      modelRelations = relationsForModel(schemaResult);
-    }
+  } else if (isServiceModel(schemaResult)) {
+    modelRelations = relationsForModel(schemaResult);
   }
   const serviceFile = await templateForFile({
     name,
@@ -283,49 +310,52 @@ const files = async ({
       relations: modelRelations,
       idName,
       prismaImportSource,
-      ...rest
-    }
-  });
-  const testFile = await templateForFile({
-    name,
-    side: "api",
-    sidePathSection: "services",
-    generator: "service",
-    outputPath: path.join(componentName, componentName + ".test.ts"),
-    templatePath: "test.ts.template",
-    templateVars: {
-      relations: relations || [],
-      create: await fieldsToInput(model),
-      update: await fieldsToUpdate(model),
-      types: await fieldTypes(model),
-      prismaImport: (await parseSchema(model)).scalarFields.some(
-        (field) => field.type === "Decimal"
-      ),
-      prismaModel: model,
-      idName,
-      prismaImportSource,
-      ...rest
-    }
-  });
-  const scenariosFile = await templateForFile({
-    name,
-    side: "api",
-    sidePathSection: "services",
-    generator: "service",
-    outputPath: path.join(componentName, componentName + ".scenarios.ts"),
-    templatePath: "scenarios.ts.template",
-    templateVars: {
-      scenario: await buildScenario(model),
-      stringifiedScenario: await buildStringifiedScenario(model),
-      prismaModel: model,
-      idName,
-      relations: modelRelations,
-      prismaImportSource,
+      updateInputRequiredFields,
+      nullableJsonFields,
+      nullableRelations,
       ...rest
     }
   });
   const files2 = [serviceFile];
   if (tests) {
+    const testFile = await templateForFile({
+      name,
+      side: "api",
+      sidePathSection: "services",
+      generator: "service",
+      outputPath: path.join(componentName, componentName + ".test.ts"),
+      templatePath: "test.ts.template",
+      templateVars: {
+        relations: relations || [],
+        create: await fieldsToInput(model),
+        update: await fieldsToUpdate(model),
+        types: await fieldTypes(model),
+        prismaImport: (await parseSchema(model)).scalarFields.some(
+          (field) => field.type === "Decimal"
+        ),
+        prismaModel: model,
+        idName,
+        prismaImportSource,
+        ...rest
+      }
+    });
+    const scenariosFile = await templateForFile({
+      name,
+      side: "api",
+      sidePathSection: "services",
+      generator: "service",
+      outputPath: path.join(componentName, componentName + ".scenarios.ts"),
+      templatePath: "scenarios.ts.template",
+      templateVars: {
+        scenario: await buildScenario(model),
+        stringifiedScenario: await buildStringifiedScenario(model),
+        prismaModel: model,
+        idName,
+        relations: modelRelations,
+        prismaImportSource,
+        ...rest
+      }
+    });
     files2.push(testFile);
     files2.push(scenariosFile);
   }

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

@@ -1,38 +1,65 @@
 import type { QueryResolvers<% if (crud) { %>, MutationResolvers<% } %><% if (relations.length) { %>, ${singularPascalName}RelationResolvers<% } %> } from 'types/graphql'
 
-import { db } from 'src/lib/db'
-
+import { db<% if (crud && nullableJsonFields.length) { %>, Prisma<% } %> } from 'src/lib/db'
+<%
+  // A compound `@@id([...])` key comes through as `{ fields, whereArg }`
+  // instead of a single field name -- build the destructure/where-clause
+  // snippets for both shapes here so the rest of the template can stay
+  // shape-agnostic.
+  const idIsComposite = idName != null && typeof idName === 'object'
+  const idFields = idIsComposite ? idName.fields : [idName]
+  const idArgs = idFields.join(', ')
+  const idWhere = idIsComposite
+    ? `${idName.whereArg}: { ${idFields.join(', ')} }`
+    : idName
+  const idWhereFromRoot = idIsComposite
+    ? `${idName.whereArg}: { ${idFields.map((f) => `${f}: root.${f}`).join(', ')} }`
+    : `${idName}: root.${idName}`
+%>
 export const ${pluralCamelName}: QueryResolvers['${pluralCamelName}'] = () => {
   return db.${singularCamelName}.findMany()
 }<% if (crud || relations.length) { %>
 
-export const ${singularCamelName}: QueryResolvers['${singularCamelName}'] = ({ ${idName} }) => {
+export const ${singularCamelName}: QueryResolvers['${singularCamelName}'] = ({ ${idArgs} }) => {
   return db.${singularCamelName}.findUnique({
-    where: { ${idName} },
+    where: { ${idWhere} },
   })
 }<% } %><% if (crud) { %>
 
 export const create${singularPascalName}: MutationResolvers['create${singularPascalName}'] = ({ input }) => {
-  return db.${singularCamelName}.create({
-    data: input,
+  return db.${singularCamelName}.create({<% if (nullableJsonFields.length) { %>
+    data: {
+      ...input,
+      // Prisma uses Prisma.DbNull, not null, to set a Json field to NULL<% nullableJsonFields.forEach((field) => { %>
+      ${field}: input.${field} === null ? Prisma.DbNull : input.${field},<% }) %>
+    },<% } else { %>
+    data: input,<% } %>
   })
 }
 
-export const update${singularPascalName}: MutationResolvers['update${singularPascalName}'] = ({ ${idName}, input }) => {
-  return db.${singularCamelName}.update({
-    data: input,
-    where: { ${idName} },
+export const update${singularPascalName}: MutationResolvers['update${singularPascalName}'] = ({ ${idArgs}, input }) => {
+  return db.${singularCamelName}.update({<% if (updateInputRequiredFields.length || nullableJsonFields.length) { %>
+    data: {
+      ...input,<% if (updateInputRequiredFields.length) { %>
+      // Every field in the GraphQL input is nullable, but Prisma doesn't
+      // accept null for required fields. undefined leaves the field unchanged<% updateInputRequiredFields.forEach((field) => { %>
+      ${field}: input.${field} ?? undefined,<% }) %><% } %><% if (nullableJsonFields.length) { %>
+      // Prisma uses Prisma.DbNull, not null, to set a Json field to NULL<% nullableJsonFields.forEach((field) => { %>
+      ${field}: input.${field} === null ? Prisma.DbNull : input.${field},<% }) %><% } %>
+    },<% } else { %>
+    data: input,<% } %>
+    where: { ${idWhere} },
   })
 }
 
-export const delete${singularPascalName}: MutationResolvers['delete${singularPascalName}'] = ({ ${idName} }) => {
+export const delete${singularPascalName}: MutationResolvers['delete${singularPascalName}'] = ({ ${idArgs} }) => {
   return db.${singularCamelName}.delete({
-    where: { ${idName} },
+    where: { ${idWhere} },
   })
 }<% } %><% if (relations.length) { %>
 
 export const ${singularPascalName}: ${singularPascalName}RelationResolvers = {<% relations.forEach(relation => { %>
   ${relation}: (_obj, { root }) => {
-    return db.${singularCamelName}.findUnique({ where: { ${idName}: root?.${idName} } }).${relation}()
+    return db.${singularCamelName}.findUnique<%= nullableRelations.includes(relation) ? '' : 'OrThrow' %>({ where: { ${idWhereFromRoot} } }).${relation}()
   },<% }) %>
 }<% } %>

package/dist/commands/generate/service/templates/test.ts.template

@@ -7,8 +7,10 @@
    // Looks for quoted strings, either by single (') or double (") quotes.
    // When found
    // - Removes the quotes around `scenario` variables.
-   // - Removes the quotes around `BigInt` fields.
-  const transformValue = (obj, type) => {
+   // - Removes the quotes around `BigInt` fields. GraphQL inputs type BigInt
+   //   values as numbers, so the `n` suffix is also removed when `asInput` is
+   //   set
+  const transformValue = (obj, type, asInput = false) => {
     if (type === 'DateTime') {
       return `new Date('${obj.toISOString()}')`
     } else if (type === 'Decimal') {
@@ -22,7 +24,7 @@
 
       // BigInt
       if (string.match(/^\"\d+n\"$/)) {
-        return string.slice(1, string.length - 1)
+        return string.slice(1, string.length - (asInput ? 2 : 1))
       }
 
       return string
@@ -40,7 +42,7 @@ import type { StandardScenario } from './${pluralCamelName}.scenarios.js'
 // and can fail without adjustments, e.g. Float.
 //           Please refer to the RedwoodJS Testing Docs:
 //       https://cedarjs.com/docs/testing#testing-services
-// https://cedarjs.com/docs/testing#jest-expect-type-considerations
+// https://cedarjs.com/docs/testing#expect-type-considerations
 
 describe('${pluralCamelName}', () => {
   scenario('returns all ${pluralCamelName}', async (scenario: StandardScenario) => {
@@ -57,7 +59,7 @@ describe('${pluralCamelName}', () => {
 
   <% if (create) { %>scenario('creates a ${singularCamelName}', async (${transformValue(create).includes('scenario.') ? 'scenario: StandardScenario' : ''}) => {
     const result = await create${singularPascalName}({
-      input: ${transformValue(create)},
+      input: ${transformValue(create, undefined, true)},
     })
 
     <% for (const [name, value] of Object.entries(create)) { %>
@@ -68,7 +70,7 @@ describe('${pluralCamelName}', () => {
     const original = await (${singularCamelName}({ ${idName}: scenario.${singularCamelName}.one.${idName} })) as ${prismaModel}
     const result = await update${singularPascalName}({
       ${idName}: original.${idName},
-      input: ${transformValue(update)},
+      input: ${transformValue(update, undefined, true)},
     })
 
     <% for (const [name, value] of Object.entries(update)) { %>

package/dist/commands/generate/yargsCommandHelpers.js

@@ -1,5 +1,5 @@
 import { terminalLink } from "termi-link";
-import { isTypeScriptProject } from "@cedarjs/cli-helpers";
+import { isTypeScriptProject } from "@cedarjs/cli-helpers/project";
 function getYargsDefaults() {
   return {
     force: {

package/dist/commands/generate/yargsHandlerHelpers.js

@@ -3,7 +3,8 @@ import path from "node:path";
 import { camelCase } from "change-case";
 import { Listr } from "listr2";
 import pascalcase from "pascalcase";
-import { recordTelemetryAttributes, colors as c } from "@cedarjs/cli-helpers";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { ensurePosixPath, getConfig } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { generateTemplate, getPaths, writeFilesTask } from "../../lib/index.js";

package/dist/commands/generate.js

@@ -1,6 +1,6 @@
 import { terminalLink } from "termi-link";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
 import { runBinSync } from "@cedarjs/cli-helpers/packageManager/exec";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import * as generateCell from "./generate/cell/cell.js";
 import * as generateComponent from "./generate/component/component.js";
 import * as generateDataMigration from "./generate/dataMigration/dataMigration.js";

package/dist/commands/info.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import envinfo from "envinfo";
 import { terminalLink } from "termi-link";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { getConfigPath } from "@cedarjs/project-config";
 const command = "info";
 const description = "Print your system environment information";

package/dist/commands/jobsHandler.js

@@ -7,9 +7,11 @@ const handler = async ({
   commands: _commands,
   ...options
 }) => {
-  const positionalArgs = Array.isArray(_) ? [..._] : [];
-  const commandArg = positionalArgs.pop();
-  const args = [commandArg == null ? "" : String(commandArg)];
+  const positionalArgs = (Array.isArray(_) ? _ : []).map(String);
+  if (positionalArgs[0] === "jobs") {
+    positionalArgs.shift();
+  }
+  const args = positionalArgs.length > 0 ? positionalArgs : [""];
   for (const [name, value] of Object.entries(options)) {
     args.push(name.length > 1 ? `--${name}` : `-${name}`);
     args.push(String(value));

package/dist/commands/lint.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import { terminalLink } from "termi-link";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
 import { runBin } from "@cedarjs/cli-helpers/packageManager/exec";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { getPaths } from "@cedarjs/project-config";
 const command = "lint [paths..]";
 const description = "Lint your files";

package/dist/commands/prerenderHandler.js

@@ -1,9 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import { Listr } from "listr2";
-import { recordTelemetryAttributes, colors as c } from "@cedarjs/cli-helpers";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
 import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
-import { getConfig, getPaths, projectIsEsm } from "@cedarjs/project-config";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
+import { getConfig, getParsedScalars, getPaths } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { runScriptFunction } from "../lib/exec.js";
 import { configureBabel } from "../lib/execBabel.js";
@@ -93,7 +94,7 @@ async function expandRouteParameters(route) {
   return [route];
 }
 const getTasks = async (dryrun, routerPathFilter = null) => {
-  const detector = projectIsEsm() ? await import("@cedarjs/prerender/detection") : await import("@cedarjs/prerender/cjs/detection");
+  const detector = await import("@cedarjs/prerender/detection");
   const detectedRoutes = detector.detectPrerenderRoutes();
   const prerenderRoutes = detectedRoutes.filter(hasPath).map(normalizeRoute);
   if (prerenderRoutes.length === 0) {
@@ -105,6 +106,12 @@ const getTasks = async (dryrun, routerPathFilter = null) => {
     );
     return [];
   }
+  const parsedScalars = Object.keys(getParsedScalars());
+  if (parsedScalars.length > 0) {
+    throw new Error(
+      "Prerendering does not support `graphql.parsedScalars` yet. A prerendered Cell gets the raw GraphQL response, so " + parsedScalars.join(", ") + " would be a string when prerendering and parsed in the browser. Either remove the `prerender` prop from your routes, or remove `graphql.parsedScalars` from cedar.toml."
+    );
+  }
   const indexHtmlPath = path.join(getPaths().web.dist, "index.html");
   if (!fs.existsSync(indexHtmlPath)) {
     console.error(
@@ -116,7 +123,7 @@ const getTasks = async (dryrun, routerPathFilter = null) => {
   const expandedRouteParameters = await Promise.all(
     prerenderRoutes.map((route) => expandRouteParameters(route))
   );
-  const prerenderer = projectIsEsm() ? await import("@cedarjs/prerender") : await import("@cedarjs/prerender/cjs");
+  const prerenderer = await import("@cedarjs/prerender");
   const listrTasks = expandedRouteParameters.flatMap((routesToPrerender) => {
     const queryCache = {};
     const shouldFold = routesToPrerender.length > 16;

package/dist/commands/prismaHandler.js

@@ -1,12 +1,13 @@
 import fs from "node:fs";
 import boxen from "boxen";
-import { recordTelemetryAttributes, colors as c } from "@cedarjs/cli-helpers";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
 import {
   formatCedarCommand,
   formatRunBinCommand,
   formatRunTransitiveBinCommand
 } from "@cedarjs/cli-helpers/packageManager/display";
 import { runTransitiveBinSync } from "@cedarjs/cli-helpers/packageManager/exec";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { getPaths } from "../lib/index.js";
 const getErrorMessage = (error) => {
@@ -62,7 +63,11 @@ const handler = async ({
   try {
     runTransitiveBinSync("prisma", args, {
       cwd: cedarPaths.base,
-      stdio: "inherit"
+      stdio: [
+        process.stdin.isTTY && !process.env.CI ? "inherit" : "pipe",
+        "inherit",
+        "inherit"
+      ]
     });
     if (hasHelpOption || args.length === 0) {
       printWrapInfo();

package/dist/commands/record/init.js

@@ -1,4 +1,4 @@
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 const handler = async (_argv) => {
   recordTelemetryAttributes({
     command: "record"

package/dist/commands/serve.js

@@ -5,7 +5,8 @@ import { serve as serveSrvx } from "srvx";
 import { terminalLink } from "termi-link";
 import * as apiServerCLIConfig from "@cedarjs/api-server/apiCliConfig";
 import * as bothServerCLIConfig from "@cedarjs/api-server/bothCliConfig";
-import { recordTelemetryAttributes, colors as c } from "@cedarjs/cli-helpers";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import * as webServerCLIConfig from "@cedarjs/web-server";
 import { getPaths, getConfig } from "../lib/index.js";
 import { serverFileExists } from "../lib/project.js";

package/dist/commands/setup/auth/auth.js

@@ -1,11 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
 import { terminalLink } from "termi-link";
-import {
-  recordTelemetryAttributes,
-  standardAuthBuilder
-} from "@cedarjs/cli-helpers";
+import { standardAuthBuilder } from "@cedarjs/cli-helpers/auth/setupHelpers";
 import { addRootPackages } from "@cedarjs/cli-helpers/packageManager/packages";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { getPaths } from "../../../lib/index.js";
 const command = "auth <provider>";
 const description = "Set up an auth configuration";

package/dist/commands/setup/cache/cache.js

@@ -1,5 +1,5 @@
 import { terminalLink } from "termi-link";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 const command = "cache <client>";
 const description = "Sets up an init file for service caching";
 const builder = (yargs) => {

package/dist/commands/setup/cache/cacheHandler.js

@@ -2,7 +2,8 @@ import fs from "node:fs";
 import path from "path";
 import { Listr } from "listr2";
 import { terminalLink } from "termi-link";
-import { addEnvVarTask, colors as c } from "@cedarjs/cli-helpers";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { addEnvVarTask } from "@cedarjs/cli-helpers/project";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { addPackagesTask, getPaths, writeFile } from "../../../lib/index.js";
 import { isTypeScriptProject } from "../../../lib/project.js";

package/dist/commands/setup/cache/templates/memcached.ts.template

@@ -10,21 +10,18 @@ const memJsFormattedLogger = {
   log: (msg: string) => logger.error(msg),
 }
 
-export let client: InMemoryClient | MemcachedClient
+// The client connects to Memcached the first time it's used. If it can't
+// connect, the error is logged and `cache()` runs the uncached function
+// instead
+export const client =
+  process.env.NODE_ENV === 'test'
+    ? new InMemoryClient()
+    : new MemcachedClient(process.env.CACHE_HOST, {
+        logger: memJsFormattedLogger,
+      })
 
-if (process.env.NODE_ENV === 'test') {
-  client = new InMemoryClient()
-} else {
-  try {
-    client = new MemcachedClient(process.env.CACHE_HOST, {
-      logger: memJsFormattedLogger,
-    })
-  } catch (e) {
-    logger.error(`Could not connect to cache: ${e.message}`)
-  }
-}
-
-export const { cache, cacheFindMany, cacheClient, deleteCacheKey } = createCache(client, {
-  logger,
-  timeout: 500,
-})
+export const { cache, cacheFindMany, cacheClient, deleteCacheKey } =
+  createCache(client, {
+    logger,
+    timeout: 500,
+  })

package/dist/commands/setup/cache/templates/redis.ts.template

@@ -1,24 +1,16 @@
-import {
-  createCache,
-  InMemoryClient,
-  RedisClient,
-} from '@cedarjs/api/cache'
+import { createCache, InMemoryClient, RedisClient } from '@cedarjs/api/cache'
 
 import { logger } from './logger'
 
-export let client: InMemoryClient | RedisClient
+// The client connects to Redis the first time it's used. If it can't connect,
+// the error is logged and `cache()` runs the uncached function instead
+export const client =
+  process.env.NODE_ENV === 'test'
+    ? new InMemoryClient()
+    : new RedisClient({ url: process.env.CACHE_HOST, logger })
 
-if (process.env.NODE_ENV === 'test') {
-  client = new InMemoryClient()
-} else {
-  try {
-    client = new RedisClient({ url: process.env.CACHE_HOST, logger })
-  } catch (e) {
-    logger.error(`Could not connect to cache: ${e.message}`)
-  }
-}
-
-export const { cache, cacheFindMany, cacheClient, deleteCacheKey } = createCache(client, {
-  logger,
-  timeout: 500,
-})
+export const { cache, cacheFindMany, cacheClient, deleteCacheKey } =
+  createCache(client, {
+    logger,
+    timeout: 500,
+  })

package/dist/commands/setup/database/postgres.js

@@ -1,4 +1,4 @@
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 const command = "postgres";
 const description = "Switch your project from SQLite to PostgreSQL (schema, dependencies, and database adapter)";
 function builder(yargs) {

package/dist/commands/setup/database/postgresHandler.js

@@ -2,9 +2,11 @@ import fs from "node:fs";
 import path from "node:path";
 import execa from "execa";
 import { Listr } from "listr2";
-import { colors, getPaths, installPackages } from "@cedarjs/cli-helpers";
+import { colors } from "@cedarjs/cli-helpers/colors";
+import { installPackages } from "@cedarjs/cli-helpers/installHelpers";
 import { prettyPrintCedarCommand } from "@cedarjs/cli-helpers/packageManager";
 import { addWorkspacePackages } from "@cedarjs/cli-helpers/packageManager/packages";
+import { getPaths } from "@cedarjs/cli-helpers/paths";
 import { resolveFile } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
 function checkProjectShape(cedarPaths) {

package/dist/commands/setup/deploy/providers/baremetal.js

@@ -1,8 +1,15 @@
+import { MONITORS } from "../../../deploy/baremetal/monitors.js";
 import { createHandler } from "../helpers/helpers.js";
 const command = "baremetal";
 const description = "Setup Baremetal deploy";
+const builder = (yargs) => yargs.option("monitor", {
+  description: "Process monitor to generate config for. Asks when not given. pm2 gets an ecosystem.config.js, systemd gets unit files in systemd/",
+  choices: MONITORS,
+  type: "string"
+});
 const handler = createHandler("baremetal");
 export {
+  builder,
   command,
   description,
   handler