@cedarjs/cli 7.0.1-next.314 → 7.0.1-next.466

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

@@ -1,6 +1,6 @@
 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
@@ -13,8 +13,8 @@ import { db } from 'src/lib/db'
     ? `${idName.whereArg}: { ${idFields.join(', ')} }`
     : idName
   const idWhereFromRoot = idIsComposite
-    ? `${idName.whereArg}: { ${idFields.map((f) => `${f}: root?.${f}`).join(', ')} }`
-    : `${idName}: root?.${idName}`
+    ? `${idName.whereArg}: { ${idFields.map((f) => `${f}: root.${f}`).join(', ')} }`
+    : `${idName}: root.${idName}`
 %>
 export const ${pluralCamelName}: QueryResolvers['${pluralCamelName}'] = () => {
   return db.${singularCamelName}.findMany()
@@ -27,14 +27,27 @@ export const ${singularCamelName}: QueryResolvers['${singularCamelName}'] = ({ $
 }<% } %><% 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}'] = ({ ${idArgs}, input }) => {
-  return db.${singularCamelName}.update({
-    data: 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} },
   })
 }
@@ -47,6 +60,6 @@ export const delete${singularPascalName}: MutationResolvers['delete${singularPas
 
 export const ${singularPascalName}: ${singularPascalName}RelationResolvers = {<% relations.forEach(relation => { %>
   ${relation}: (_obj, { root }) => {
-    return db.${singularCamelName}.findUnique({ where: { ${idWhereFromRoot} } }).${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
@@ -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/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/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/deploy/helpers/index.js

@@ -131,7 +131,9 @@ function insertPluginsBeforeCedar({
   if (!configArg) {
     return null;
   }
-  const pluginsProp = configArg.properties.find(t.isObjectProperty);
+  const pluginsProp = configArg.properties.find(
+    (prop) => t.isObjectProperty(prop) && (!prop.computed && t.isIdentifier(prop.key, { name: "plugins" }) || t.isStringLiteral(prop.key, { value: "plugins" }))
+  );
   if (!t.isArrayExpression(pluginsProp?.value)) {
     return null;
   }

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

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

@@ -10,38 +10,136 @@ import {
   getPaths,
   printSetupNotes
 } from "../../../../lib/index.js";
+import { MONITORS, isMonitor } from "../../../deploy/baremetal/monitors.js";
 import { addFilesTask } from "../helpers/index.js";
-import { DEPLOY, ECOSYSTEM, MAINTENANCE } from "../templates/baremetal.js";
+import {
+  MAINTENANCE,
+  SYSTEMD_DIR,
+  deployToml,
+  ecosystemConfig,
+  systemdJobsUnit,
+  systemdServiceUnit
+} from "../templates/baremetal.js";
 const configFilename = "deploy.toml";
-const files = [
+const MONITOR_CHOICES = [
   {
-    path: path.join(getPaths().base, configFilename),
-    content: DEPLOY
+    title: "pm2",
+    description: "Node process manager, configured in ecosystem.config.js",
+    value: "pm2"
   },
   {
-    path: path.join(getPaths().base, "ecosystem.config.js"),
-    content: ECOSYSTEM
+    title: "systemd (user units)",
+    description: "Units in ~/.config/systemd/user, managed by the deploy user without sudo",
+    value: "systemd-user"
   },
   {
-    path: path.join(getPaths().web.src, "maintenance.html"),
-    content: MAINTENANCE
+    title: "systemd (system units)",
+    description: "Units in /etc/systemd/system, managed with sudo systemctl",
+    value: "systemd-system"
   }
 ];
-const notes = [
-  "You are almost ready to go BAREMETAL!",
-  "",
-  "See https://cedarjs.com/docs/deploy/baremetal for the remaining",
-  "config and setup required before you can perform your first deploy."
-];
-const handler = async ({ force }) => {
+const appNameFromPath = (projectPath) => {
+  const name = path.basename(projectPath).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return name || "cedar";
+};
+const setupFiles = ({
+  monitor,
+  jobs,
+  appName,
+  basePath,
+  webSrcPath
+}) => {
+  const files = [];
+  let processNames;
+  if (monitor === "pm2") {
+    processNames = jobs ? ["serve", "jobs"] : ["serve"];
+    files.push({
+      path: path.join(basePath, "ecosystem.config.js"),
+      content: ecosystemConfig({ jobs })
+    });
+  } else {
+    const jobsUnit = `${appName}-jobs`;
+    processNames = jobs ? [appName, `${jobsUnit}@0`] : [appName];
+    files.push({
+      path: path.join(basePath, SYSTEMD_DIR, `${appName}.service`),
+      content: systemdServiceUnit({ appName, monitor })
+    });
+    if (jobs) {
+      files.push({
+        path: path.join(basePath, SYSTEMD_DIR, `${jobsUnit}@.service`),
+        content: systemdJobsUnit({ appName, monitor })
+      });
+    }
+  }
+  files.unshift({
+    path: path.join(basePath, configFilename),
+    content: deployToml({ monitor, processNames })
+  });
+  files.push({
+    path: path.join(webSrcPath, "maintenance.html"),
+    content: MAINTENANCE
+  });
+  return { files, processNames };
+};
+const notesFor = (monitor, jobs, processNames) => {
+  const notes = ["You are almost ready to go BAREMETAL!", ""];
+  if (monitor !== "pm2") {
+    notes.push(
+      `Copy the unit files in ${SYSTEMD_DIR}/ to the server before your first`,
+      "deploy. The comments at the top of each file say where they go.",
+      ""
+    );
+  }
+  if (jobs) {
+    notes.push(
+      `Background jobs are set up, so deploy.toml lists a jobs worker process`,
+      `(${processNames[processNames.length - 1]}). Add one per entry in the`,
+      "`workers` array of api/src/lib/jobs.ts.",
+      ""
+    );
+  }
+  notes.push(
+    "See https://cedarjs.com/docs/deploy/baremetal for the remaining",
+    "config and setup required before you can perform your first deploy."
+  );
+  return notes;
+};
+const promptForMonitor = async () => {
+  const { monitor } = await prompts({
+    type: "select",
+    name: "monitor",
+    message: "Which process monitor will run your app on the server?",
+    choices: MONITOR_CHOICES
+  });
+  return isMonitor(monitor) ? monitor : void 0;
+};
+const handler = async ({
+  force,
+  monitor: monitorOption
+}) => {
   recordTelemetryAttributes({
     command: "setup deploy baremetal",
-    force
+    force,
+    monitor: monitorOption
   });
-  if (fs.existsSync(path.join(getPaths().base, ".pnp.cjs"))) {
+  if (monitorOption !== void 0 && !isMonitor(monitorOption)) {
+    console.error(
+      c.error(
+        `Unknown monitor "${monitorOption}". Use one of ${MONITORS.join(", ")}.`
+      )
+    );
+    process.exit(1);
+  }
+  const monitor = monitorOption ?? await promptForMonitor();
+  if (!monitor) {
+    console.log("Aborting baremetal setup.");
+    return;
+  }
+  const paths = getPaths();
+  if (fs.existsSync(path.join(paths.base, ".pnp.cjs"))) {
     console.warn(
       c.warning(
-        "Your project uses Yarn PnP (Plug'n'Play), which is not officially supported for Baremetal deployments. The generated ecosystem.config.js file uses node_modules/.bin/cedar as the PM2 script path, which will most likely not work under PnP.\n\nYou will need to manually configure the server. See also the packageManagerCommand field in deploy.toml."
+        "Your project uses Yarn PnP (Plug'n'Play), which is not officially supported for Baremetal deployments. The generated process config starts the app with node_modules/.bin/cedar, which will most likely not work under PnP.\n\nYou will need to manually configure the server. See also the packageManagerCommand field in deploy.toml."
       )
     );
     console.log();
@@ -56,6 +154,14 @@ const handler = async ({ force }) => {
     }
     console.log();
   }
+  const jobs = Boolean(paths.api.jobsConfig);
+  const { files, processNames } = setupFiles({
+    monitor,
+    jobs,
+    appName: appNameFromPath(paths.base),
+    basePath: paths.base,
+    webSrcPath: paths.web.src
+  });
   const tasks = new Listr(
     [
       await addPackagesTask({
@@ -66,7 +172,7 @@ const handler = async ({ force }) => {
         files,
         force
       }),
-      printSetupNotes(notes)
+      printSetupNotes(notesFor(monitor, jobs, processNames))
     ],
     { rendererOptions: { collapseSubtasks: false } }
   );
@@ -81,6 +187,8 @@ const handler = async ({ force }) => {
   }
 };
 export {
+  appNameFromPath,
   configFilename,
-  handler
+  handler,
+  setupFiles
 };

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

@@ -56,11 +56,17 @@ function addNetlifyPluginsToViteConfigTask() {
       const hasNetlifyCompat = content.includes(
         "@universal-deploy/netlify/vite"
       );
-      if (hasNetlifyPlugin && hasNetlifyCompat && content.includes("netlifyCompat(")) {
+      const hasSkewProtectionImport = content.includes(
+        "cedarNetlifySkewProtectionPlugin"
+      );
+      const hasSkewProtectionCall = content.includes(
+        "cedarNetlifySkewProtectionPlugin("
+      );
+      if (hasNetlifyPlugin && hasNetlifyCompat && hasSkewProtectionImport && hasSkewProtectionCall && content.includes("netlifyCompat(")) {
         task.skip("Netlify plugins are already configured.");
         return;
       }
-      if (!hasNetlifyPlugin || !hasNetlifyCompat) {
+      if (!hasNetlifyPlugin || !hasNetlifyCompat || !hasSkewProtectionImport) {
         const newContent = content.replace(
           /(import\s+\{[^}]*\}\s+from\s+['"]vite['"];?)/,
           (match) => {
@@ -71,6 +77,10 @@ ${result}`;
             }
             if (!hasNetlifyCompat) {
               result = `import netlifyCompat from '@universal-deploy/netlify/vite'
+${result}`;
+            }
+            if (!hasSkewProtectionImport) {
+              result = `import { cedarNetlifySkewProtectionPlugin } from '@cedarjs/vite'
 ${result}`;
             }
             return result;
@@ -84,6 +94,9 @@ ${result}`;
           if (!hasNetlifyCompat) {
             prepend += "import netlifyCompat from '@universal-deploy/netlify/vite'\n";
           }
+          if (!hasSkewProtectionImport) {
+            prepend += "import { cedarNetlifySkewProtectionPlugin } from '@cedarjs/vite'\n";
+          }
           content = prepend + content;
         } else {
           content = newContent;
@@ -94,12 +107,21 @@ ${result}`;
           content,
           pluginCodes: [
             "netlify({ build: { enabled: true } })",
-            "netlifyCompat()"
+            "netlifyCompat()",
+            "cedarNetlifySkewProtectionPlugin()"
           ]
         });
         if (result) {
           content = result;
         }
+      } else if (!hasSkewProtectionCall) {
+        const result = insertPluginsBeforeCedar({
+          content,
+          pluginCodes: ["cedarNetlifySkewProtectionPlugin()"]
+        });
+        if (result) {
+          content = result;
+        }
       }
       fs.writeFileSync(viteConfigPath, content);
     }

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

@@ -1,5 +1,26 @@
 import { getPackageManager } from "@cedarjs/project-config/packageManager";
-const ECOSYSTEM = `module.exports = {
+const SYSTEMD_DIR = "systemd";
+const JOBS_WORKER_BIN = "api/node_modules/.bin/cedar-jobs-worker";
+const WORKER_STOP_TIMEOUT_SECONDS = 600;
+const JOBS_WORKER_COMMENT = `# Runs one background jobs worker. \`--index\` picks the entry of the \`workers\`
+# array in api/src/lib/jobs.ts and \`--id\` numbers the worker within that
+# entry, so an entry with \`count: 2\` needs a second worker with \`--id=1\`.`;
+const ecosystemConfig = ({ jobs }) => {
+  const jobsApp = jobs ? `
+    {
+      // Runs one background jobs worker. \`--index\` picks the entry of the
+      // \`workers\` array in api/src/lib/jobs.ts and \`--id\` numbers the worker
+      // within that entry, so an entry with \`count: 2\` needs a second app
+      // with \`--id=1\`.
+      name: 'jobs',
+      cwd: 'current',
+      script: '${JOBS_WORKER_BIN}',
+      args: '--index=0 --id=0',
+      // pm2 stops the worker with SIGINT, which lets it finish the job it is
+      // running. This is how long pm2 waits for that (in ms) before killing it.
+      kill_timeout: ${WORKER_STOP_TIMEOUT_SECONDS * 1e3},
+    },` : "";
+  return `module.exports = {
   apps: [
     {
       name: 'serve',
@@ -10,10 +31,79 @@ const ECOSYSTEM = `module.exports = {
       exec_mode: 'cluster',
       wait_ready: true,
       listen_timeout: 10000,
-    },
+    },${jobsApp}
   ],
-}`;
-const DEPLOY = `# This file contains config for a baremetal deployment
+}
+`;
+};
+const unitHeader = (appName, monitor) => {
+  const install = monitor === "systemd-system" ? `#   sudo cp ${SYSTEMD_DIR}/*.service /etc/systemd/system/` : `#   mkdir -p ~/.config/systemd/user && cp ${SYSTEMD_DIR}/*.service ~/.config/systemd/user/`;
+  const linger = monitor === "systemd-system" ? "" : `#
+# User units only run while the user has a session, so let them run after a
+# reboot too:
+#   sudo loginctl enable-linger $(whoami)
+`;
+  return `# systemd unit for the ${appName} Cedar app, generated by \`cedar setup deploy baremetal\`.
+#
+# Copy the unit files to the server once, before the first deploy:
+${install}
+${linger}#
+# Then deploy with \`--first-run\`, which reloads the unit files and enables and
+# starts every process listed in deploy.toml.
+#
+# WorkingDirectory must be the \`path\` from deploy.toml followed by \`/current\`.`;
+};
+const unitService = (monitor, execStart, extraDirectives = "") => {
+  const user = monitor === "systemd-system" ? "\nUser=deploy" : "";
+  return `[Service]
+WorkingDirectory=/var/www/app/current
+# A login shell puts node and ${getPackageManager()} from a version manager such as nvm on the PATH
+ExecStart=/bin/bash -lc '${execStart}'
+Restart=always
+RestartSec=5
+Environment=NODE_ENV=production${user}${extraDirectives}`;
+};
+const JOBS_STOP_DIRECTIVES = `
+# Stopping sends SIGINT so the worker finishes the job it is running before it
+# exits. systemd waits this long for that before killing the worker.
+KillSignal=SIGINT
+TimeoutStopSec=${WORKER_STOP_TIMEOUT_SECONDS}`;
+const unitInstall = (monitor) => `[Install]
+WantedBy=${monitor === "systemd-system" ? "multi-user.target" : "default.target"}`;
+const systemdServiceUnit = ({
+  appName,
+  monitor
+}) => `${unitHeader(appName, monitor)}
+
+[Unit]
+Description=${appName} (Cedar)
+After=network.target
+
+${unitService(monitor, "exec node_modules/.bin/cedar serve")}
+
+${unitInstall(monitor)}
+`;
+const systemdJobsUnit = ({
+  appName,
+  monitor
+}) => `${unitHeader(appName, monitor)}
+#
+${JOBS_WORKER_COMMENT}
+# Start one instance per \`workers\` entry: \`${appName}-jobs@0\`, \`${appName}-jobs@1\`
+# and so on, and list each one in \`processNames\` in deploy.toml.
+
+[Unit]
+Description=${appName} background jobs worker %i (Cedar)
+After=network.target
+
+${unitService(monitor, `exec ${JOBS_WORKER_BIN} --index=%i --id=0`, JOBS_STOP_DIRECTIVES)}
+
+${unitInstall(monitor)}
+`;
+const deployToml = ({
+  monitor,
+  processNames
+}) => `# This file contains config for a baremetal deployment
 #
 # SSH connection options include:
 #
@@ -26,6 +116,22 @@ const DEPLOY = `# This file contains config for a baremetal deployment
 # * passphrase - used if your private key has a passphrase
 # * agentForward - set to \`true\` to forward the client machine's ssh credentials
 #
+# Process monitor options:
+#
+# * monitor - "pm2", "systemd-user" or "systemd-system". Decides how processes
+#   are started for the first time, restarted and stopped
+# * monitorCommand - overrides the command the monitor is invoked with. Defaults
+#   to \`pm2\`, \`systemctl --user\` or \`sudo systemctl\` depending on \`monitor\`,
+#   for example \`doppler run -- pm2\`
+# * processNames - the pm2 app names or systemd unit names to (re)start
+#
+# After restarting the processes, the deploy requests the api side's health
+# check endpoint on the server and fails if it doesn't respond in time:
+#
+# * healthCheckUrl - defaults to http://localhost:<[api].port>/graphql/health
+#   on servers that host the api side. Set to \`false\` to skip the check
+# * healthCheckTimeout - seconds to keep retrying, defaults to 30
+#
 # See https://cedarjs.com/docs/deploy/baremetal for more info
 
 [[production.servers]]
@@ -34,13 +140,14 @@ username = "user"
 agentForward = true
 sides = ["api","web"]
 packageManagerCommand = "${getPackageManager()}"
-monitorCommand = "pm2"
+monitor = "${monitor}"
 path = "/var/www/app"
-processNames = ["serve"]
+processNames = [${processNames.map((name) => `"${name}"`).join(", ")}]
 repo = "git@github.com:myorg/myapp.git"
 branch = "main"
 keepReleases = 5
 freeSpaceRequired = 2048
+healthCheckTimeout = 30
 
 # If you have separate api and web servers:
 #
@@ -123,7 +230,10 @@ And take it back down with:
 </html>
 `;
 export {
-  DEPLOY,
-  ECOSYSTEM,
-  MAINTENANCE
+  MAINTENANCE,
+  SYSTEMD_DIR,
+  deployToml,
+  ecosystemConfig,
+  systemdJobsUnit,
+  systemdServiceUnit
 };

package/dist/commands/setup/deploy/templates/netlifyUD.js

@@ -10,6 +10,9 @@ NODE_VERSION = "24"
 
 [functions]
 directory = "api/dist/ud"
+# Sandboxed child scripts (\`@cedarjs/api/sandbox\`) and the packages they
+# import. Nothing imports them, so Netlify's file tracing can't find them
+included_files = ["api/dist/ud/sandbox-children/**"]
 
 # To use Netlify Dev, install Netlify's CLI (\`netlify-cli\`) from NPM and use
 # \`netlify link\` to connect your local project to a site on Netlify. Then run

package/dist/commands/setup/jobs/jobsHandler.js

@@ -23,6 +23,8 @@ model BackgroundJob {
   lockedBy  String?
   lastError String?
   failedAt  DateTime?
+  key       String?   @unique
+  pausedAt  DateTime?
   createdAt DateTime  @default(now())
   updatedAt DateTime  @updatedAt
 }

package/dist/commands/setup/monitoring/sentry/sentryHandler.js

@@ -76,7 +76,6 @@ const handler = async ({ force }) => {
           "export const handler = createGraphQLHandler({",
           "extraPlugins: [useSentry({",
           "  includeRawResult: true,",
-          "  includeResolverArgs: true,",
           "  includeExecuteVariables: true,",
           "})],"
         );
@@ -112,7 +111,11 @@ const handler = async ({ force }) => {
         contentLines.splice(
           boundaryOpenIndex,
           1,
-          "<Sentry.ErrorBoundary fallback={FatalErrorPage}>"
+          "<Sentry.ErrorBoundary",
+          "  fallback={({ error }) => (",
+          "    <FatalErrorPage error={error instanceof Error ? error : undefined} />",
+          "  )}",
+          ">"
         );
         const boundaryCloseIndex = contentLines.findLastIndex(
           (line) => line.includes("</FatalErrorBoundary>")