@cedarjs/cli 7.1.0 → 7.1.1-next.468

package/dist/commands/setup/uploads/templates/uploads.ts.template

@@ -0,0 +1,98 @@
+import {
+  acceptedContentType,
+  confirmUpload as confirmUploadRecord,
+  createPresignedUpload,
+  getUploadTokenPayload,
+  issueUploadToken,
+  resolveProfile,
+  resolveTarget,
+  storeFile,
+  UploadError,
+} from '@cedarjs/uploads'
+
+import { db } from 'src/lib/db'
+import { profiles, targets } from 'src/lib/uploads'
+
+const secret = () => {
+  if (!process.env.UPLOAD_TOKEN_SECRET) {
+    throw new Error(
+      'UPLOAD_TOKEN_SECRET is not set. Generate one with `yarn cedar generate secret` and add it to .env.',
+    )
+  }
+
+  return process.env.UPLOAD_TOKEN_SECRET
+}
+
+export const requestUploadToken = ({ profile }: { profile: string }) => {
+  return issueUploadToken({
+    profiles,
+    profile,
+    secret: secret(),
+    currentUser: context.currentUser,
+  })
+}
+
+export const createPresignedUploadUrl = ({
+  input,
+}: {
+  input: { filename: string; contentType: string; size: bigint | number }
+}) => {
+  return createPresignedUpload({
+    db,
+    targets,
+    tokenPayload: getUploadTokenPayload(context),
+    input,
+  })
+}
+
+export const confirmUpload = ({ uploadId }: { uploadId: string }) => {
+  return confirmUploadRecord({
+    db,
+    targets,
+    uploadId,
+    currentUser: context.currentUser,
+  })
+}
+
+export const uploadFile = async ({
+  profile: profileName,
+  input,
+}: {
+  profile: string
+  input: { filename: string; mimeType: string; data: string }
+}) => {
+  const profile = resolveProfile(profiles, profileName)
+  const target = resolveTarget(targets, profile.target)
+
+  if (target.providerType !== 'db') {
+    throw new UploadError(
+      'NOT_SUPPORTED',
+      `Upload profile '${profile.name}' does not store files in the database. Use an upload token instead.`,
+    )
+  }
+
+  // Checked by what the bytes are, not the type the client claimed, and
+  // stored under the type returned
+  const data = Buffer.from(input.data, 'base64')
+  const mimeType = acceptedContentType(
+    data,
+    profile.allowedMimeTypes,
+    input.mimeType,
+  )
+
+  if (!mimeType) {
+    throw new UploadError(
+      'MIME_TYPE_NOT_ALLOWED',
+      `That file is not a type allowed for upload profile '${profile.name}'.`,
+    )
+  }
+
+  return storeFile(target, {
+    db,
+    filename: input.filename,
+    mimeType,
+    data,
+    maxSize: profile.maxFileSize,
+    userId: context.currentUser ? String(context.currentUser.id) : undefined,
+  })
+}

package/dist/commands/setup/uploads/templates/withDataUri.ts.template

@@ -0,0 +1,14 @@
+import { createWithDataUriDirective } from '@cedarjs/uploads'
+
+import { db } from 'src/lib/db'
+import { targets } from 'src/lib/uploads'
+
+/**
+ * Resolves a field holding an Upload id to a base64 data: URI of the file.
+ * Every resolved field embeds the whole file, so use it for small files only.
+ */
+const withDataUri = createWithDataUriDirective({ db, targets })
+
+export const schema = withDataUri.schema
+
+export default withDataUri

package/dist/commands/setup/uploads/templates/withSignedUrl.ts.template

@@ -0,0 +1,16 @@
+import { createWithSignedUrlDirective } from '@cedarjs/uploads'
+
+import { db } from 'src/lib/db'
+import { targets } from 'src/lib/uploads'
+
+/**
+ * Resolves a field holding an Upload id to a time-limited URL for the file,
+ * from whichever storage target holds it. Files download by default; pass
+ * `disposition: 'inline'` to render them in the browser instead, and only
+ * for MIME types you trust.
+ */
+const withSignedUrl = createWithSignedUrlDirective({ db, targets })
+
+export const schema = withSignedUrl.schema
+
+export default withSignedUrl

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

@@ -1,26 +1,68 @@
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import prompts from "prompts";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
+import { requireTTYOrExit } from "@cedarjs/cli-helpers/tty";
 const command = "uploads";
-const description = "Setup uploads and storage. This will install the required packages and add the required initial configuration to your redwood app.";
+const description = "Set up file uploads and storage: storage targets, upload profiles, the upload routes, and the GraphQL API";
+const TARGET_CHOICES = ["fs", "db", "s3"];
+const TARGET_DESCRIPTIONS = {
+  fs: "Local filesystem, uploaded through the api server (development, single-server deploys)",
+  db: "Inline in the database, for small files like avatars and thumbnails",
+  s3: "S3 or S3-compatible storage, uploaded straight from the browser with presigned URLs"
+};
 const builder = (yargs) => {
-  yargs.option("force", {
+  return yargs.option("targets", {
+    choices: TARGET_CHOICES,
+    description: "Storage targets to configure: fs (local filesystem), db (inline in the database), s3 (direct-to-S3 presigned uploads). Prompts when omitted.",
+    type: "array"
+  }).option("force", {
     alias: "f",
     default: false,
     description: "Overwrite existing configuration",
     type: "boolean"
   });
 };
+function toTargetChoices(values) {
+  const choices = TARGET_CHOICES;
+  return [...new Set(values)].filter(
+    (t) => choices.includes(t)
+  );
+}
+async function promptForTargets() {
+  requireTTYOrExit("--targets");
+  const response = await prompts({
+    type: "multiselect",
+    name: "targets",
+    message: "Which storage targets do you want to configure?",
+    instructions: false,
+    hint: "Space to toggle, enter to confirm",
+    min: 1,
+    choices: TARGET_CHOICES.map((value) => ({
+      title: value,
+      description: TARGET_DESCRIPTIONS[value],
+      value,
+      selected: value !== "s3"
+    }))
+  });
+  if (response.targets === void 0) {
+    process.exit(0);
+  }
+  return toTargetChoices(response.targets);
+}
 const handler = async (options) => {
+  const targets = options.targets?.length ? toTargetChoices(options.targets) : await promptForTargets();
   recordTelemetryAttributes({
     command: "setup uploads",
-    force: options.force,
-    skipExamples: options.skipExamples
+    targets: targets.join(","),
+    force: options.force
   });
   const { handler: handler2 } = await import("./uploadsHandler.js");
-  return handler2(options);
+  return handler2({ targets, force: options.force });
 };
 export {
+  TARGET_CHOICES,
   builder,
   command,
   description,
-  handler
+  handler,
+  toTargetChoices
 };

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

@@ -1,105 +1,298 @@
 import fs from "node:fs";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 import { Listr } from "listr2";
 import { format } from "prettier";
 import { terminalLink } from "termi-link";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { getPrettierOptions } from "@cedarjs/cli-helpers/fileHelpers";
 import {
   addApiPackages,
-  getPrettierOptions,
-  colors as c
-} from "@cedarjs/cli-helpers";
+  addWebPackages
+} from "@cedarjs/cli-helpers/installHelpers";
 import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
+import { addEnvVar } from "@cedarjs/cli-helpers/project";
+import { getSchemaPath } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { getPaths, transformTSToJS, writeFile } from "../../../lib/index.js";
 import { isTypeScriptProject } from "../../../lib/project.js";
-import { runTransform } from "../../../lib/runTransform.js";
-const handler = async ({ force }) => {
+import { generateSecret } from "../../generate/secret/secret.js";
+import { setupServerFileTasks } from "../server-file/serverFileHandler.js";
+import { transformGitignore } from "./gitignore.js";
+import { addUploadModel } from "./schemaPrisma.js";
+import {
+  addUploadsPlugin,
+  detectServerAuth,
+  hasUploadsPlugin
+} from "./serverFile.js";
+const UPPY_VERSION = "^6.0.0";
+const S3_IMPORTS = `import { S3Client } from '@aws-sdk/client-s3'
+
+import { createS3Provider } from '@cedarjs/uploads/s3'
+`;
+const S3_CLIENT = `
+// Your own S3 client. It stays available for S3-specific work (lifecycle
+// rules, CORS, and so on) alongside the storage target below. Credentials
+// come from the SDK's default chain: AWS_ACCESS_KEY_ID and
+// AWS_SECRET_ACCESS_KEY in .env, or an IAM role, SSO, or container
+// credentials in production. For an S3-compatible service, add \`endpoint\`
+// and \`forcePathStyle: true\`.
+export const s3Client = new S3Client({
+  region: process.env.AWS_REGION,
+})
+
+const s3Bucket = process.env.S3_BUCKET_UPLOADS
+
+if (!s3Bucket) {
+  throw new Error('Set S3_BUCKET_UPLOADS in .env to use the S3 storage target')
+}
+`;
+const TARGET_BLOCKS = {
+  fs: `  // Files uploaded through the api server and stored on local disk. Good for
+  // development and single-server deploys.
+  local: createFsProvider({
+    uploadDir: path.join(getPaths().api.base, '.uploads'),
+    serveBaseUrl: process.env.UPLOAD_SERVE_BASE_URL,
+    signSecret: process.env.UPLOAD_TOKEN_SECRET,
+  }),
+`,
+  db: `  // Small files stored inline in the Upload row (avatars, thumbnails).
+  thumbnails: createDbProvider(),
+`,
+  s3: `  // Files uploaded straight from the browser to S3 with presigned URLs.
+  files: createS3Provider({
+    client: s3Client,
+    bucket: s3Bucket,
+    region: process.env.AWS_REGION,
+    keyPrefix: 'uploads/',
+  }),
+`
+};
+const PROFILE_BLOCKS = {
+  fs: `  attachment: {
+    target: 'local',
+    allowedMimeTypes: ['application/pdf', 'image/png', 'image/jpeg'],
+    maxFileSize: 25 * 1024 * 1024,
+    maxFiles: 10,
+  },
+`,
+  db: `  avatar: {
+    target: 'thumbnails',
+    allowedMimeTypes: ['image/png', 'image/jpeg'],
+    maxFileSize: DB_MAX_FILE_SIZE,
+    maxFiles: 1,
+  },
+`,
+  s3: `  document: {
+    target: 'files',
+    allowedMimeTypes: ['application/pdf', 'image/*'],
+    maxFileSize: 100 * 1024 * 1024,
+    maxFiles: 5,
+  },
+`
+};
+const handler = async ({ targets, force }) => {
+  const paths = getPaths();
   const projectIsTypescript = isTypeScriptProject();
-  const packageJson = await import(path.join(getPaths().base, "package.json"), {
-    with: { type: "json" }
-  });
+  const ext = projectIsTypescript ? "ts" : "js";
+  const wantsFs = targets.includes("fs");
+  const wantsDb = targets.includes("db");
+  const wantsS3 = targets.includes("s3");
+  const wantsUppy = wantsFs || wantsS3;
+  const packageJson = await import(pathToFileURL(path.join(paths.base, "package.json")).href, { with: { type: "json" } });
   const cedarVersion = packageJson.default.devDependencies["@cedarjs/core"] ?? "latest";
+  const serverFilePath = path.join(paths.api.src, `server.${ext}`);
+  const writeTemplateFile = async (templateFile, outputPath, replacements = {}) => {
+    const templatePath = path.resolve(
+      import.meta.dirname,
+      "templates",
+      templateFile
+    );
+    let templateContent = fs.readFileSync(templatePath, "utf-8");
+    for (const [token, value] of Object.entries(replacements)) {
+      templateContent = templateContent.replaceAll(token, value);
+    }
+    const content = projectIsTypescript ? templateContent : await transformTSToJS(outputPath, templateContent);
+    return writeFile(outputPath, content, { overwriteExisting: force });
+  };
+  const apiPackages = [`@cedarjs/uploads@${cedarVersion}`];
+  const webPackages = [`@cedarjs/uploads@${cedarVersion}`];
+  if (wantsS3) {
+    apiPackages.push("@aws-sdk/client-s3", "@aws-sdk/s3-request-presigner");
+  }
+  if (wantsUppy) {
+    webPackages.push(
+      `@uppy/core@${UPPY_VERSION}`,
+      `@uppy/react@${UPPY_VERSION}`,
+      `@uppy/dashboard@${UPPY_VERSION}`
+    );
+  }
+  if (wantsFs) {
+    webPackages.push(`@uppy/xhr-upload@${UPPY_VERSION}`);
+  }
+  if (wantsS3) {
+    webPackages.push(`@uppy/aws-s3@${UPPY_VERSION}`);
+  }
   const tasks = new Listr(
     [
       {
-        title: `Adding api/src/lib/uploads.${projectIsTypescript ? "ts" : "js"}...`,
+        ...addApiPackages(apiPackages),
+        title: "Adding @cedarjs/uploads to your api side..."
+      },
+      {
+        ...addWebPackages(webPackages),
+        title: "Adding @cedarjs/uploads to your web side..."
+      },
+      {
+        title: "Adding the Upload model to schema.prisma...",
         task: async () => {
-          const templatePath = path.resolve(
-            import.meta.dirname,
-            "templates",
-            "srcLibUploads.ts.template"
-          );
-          const templateContent = fs.readFileSync(templatePath, {
-            encoding: "utf8",
-            flag: "r"
-          });
-          const uploadsPath = path.join(
-            getPaths().api.lib,
-            `uploads.${projectIsTypescript ? "ts" : "js"}`
+          const schemaPath = await getSchemaPath(paths.api.prismaConfig);
+          const schema = fs.readFileSync(schemaPath, "utf-8");
+          fs.writeFileSync(schemaPath, addUploadModel(schema));
+        }
+      },
+      {
+        title: `Adding api/src/lib/uploads.${ext}...`,
+        task: async () => {
+          await writeTemplateFile(
+            "srcLibUploads.ts.template",
+            path.join(paths.api.lib, `uploads.${ext}`),
+            {
+              __S3_IMPORTS__: wantsS3 ? S3_IMPORTS : "",
+              __S3_CLIENT__: wantsS3 ? S3_CLIENT : "",
+              __FS_IMPORT__: wantsFs ? "createFsProvider," : "",
+              __DB_IMPORT__: wantsDb ? "createDbProvider," : "",
+              __DB_MAX_IMPORT__: wantsDb ? "DB_MAX_FILE_SIZE," : "",
+              __PATH_IMPORT__: wantsFs ? "import path from 'node:path'\n\n" : "",
+              __GET_PATHS_IMPORT__: wantsFs ? "import { getPaths } from '@cedarjs/project-config'\n" : "",
+              __TARGETS__: targets.map((t) => TARGET_BLOCKS[t]).join("\n"),
+              __PROFILES__: targets.map((t) => PROFILE_BLOCKS[t]).join("\n")
+            }
           );
-          const uploadsContent = projectIsTypescript ? templateContent : await transformTSToJS(uploadsPath, templateContent);
-          return writeFile(uploadsPath, uploadsContent, {
-            overwriteExisting: force
-          });
         }
       },
       {
-        title: `Adding signedUrl function...`,
+        title: "Adding the uploads SDL and service...",
         task: async () => {
-          const templatePath = path.resolve(
-            import.meta.dirname,
-            "templates",
-            "signedUrl.ts.template"
+          await writeTemplateFile(
+            "uploads.sdl.ts.template",
+            path.join(paths.api.graphql, `uploads.sdl.${ext}`)
           );
-          const templateContent = fs.readFileSync(templatePath, {
-            encoding: "utf8",
-            flag: "r"
-          });
-          const uploadsPath = path.join(
-            getPaths().api.functions,
-            `signedUrl.${projectIsTypescript ? "ts" : "js"}`
+          await writeTemplateFile(
+            "uploads.ts.template",
+            path.join(paths.api.services, "uploads", `uploads.${ext}`)
           );
-          const uploadsContent = projectIsTypescript ? templateContent : await transformTSToJS(uploadsPath, templateContent);
-          return writeFile(uploadsPath, uploadsContent, {
-            overwriteExisting: force
-          });
         }
       },
       {
-        ...addApiPackages([`@cedarjs/storage@${cedarVersion}`]),
-        title: "Adding dependencies to your api side..."
+        title: "Adding the upload directives...",
+        task: async () => {
+          const directives = ["requireUploadToken", "withSignedUrl"];
+          if (wantsDb) {
+            directives.push("withDataUri");
+          }
+          for (const name of directives) {
+            await writeTemplateFile(
+              `${name}.ts.template`,
+              path.join(paths.api.directives, name, `${name}.${ext}`)
+            );
+          }
+        }
       },
       {
-        title: "Modifying api/src/lib/db to add uploads prisma extension..",
-        task: async () => {
-          const dbPath = path.join(
-            getPaths().api.lib,
-            `db.${projectIsTypescript ? "ts" : "js"}`
-          );
-          const transformResult = await runTransform({
-            transformPath: path.join(import.meta.dirname, "dbCodemod.js"),
-            targetPaths: [dbPath]
-          });
-          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/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"
-              );
-            }
+        title: "Adding the server file...",
+        task: (_ctx, task) => task.newListr(setupServerFileTasks({ force: false })),
+        skip: () => fs.existsSync(serverFilePath) ? "api/src/server already exists; skipping." : false
+      },
+      {
+        title: "Registering the upload plugin in api/src/server...",
+        task: async (_ctx, task) => {
+          const source = fs.readFileSync(serverFilePath, "utf-8");
+          if (hasUploadsPlugin(source)) {
+            task.skip("The upload plugin is already registered; skipping.");
+            return;
+          }
+          const graphqlPath = path.join(paths.api.functions, `graphql.${ext}`);
+          const authPath = path.join(paths.api.lib, `auth.${ext}`);
+          const auth = fs.existsSync(graphqlPath) && fs.existsSync(authPath) && fs.readFileSync(authPath, "utf-8").includes("getCurrentUser") ? detectServerAuth(fs.readFileSync(graphqlPath, "utf-8")) : null;
+          let updated;
+          try {
+            updated = addUploadsPlugin(source, { auth });
+          } catch {
             throw new Error(
-              "Could not add the prisma extension. \n Please modify your api/src/lib/db to include the prisma extension: https://cedarjs.com/docs/uploads/#attaching-the-prisma-extension"
+              `Could not find \`await server.start()\` in ${path.relative(
+                paths.base,
+                serverFilePath
+              )}. Register the plugin by hand before the server starts:
+
+  import { cedarUploadsPlugin } from '@cedarjs/uploads'
+  import { db } from 'src/lib/db'
+  import { targets } from 'src/lib/uploads'
+
+  await server.register(cedarUploadsPlugin, {
+    tokenSecret: process.env.UPLOAD_TOKEN_SECRET,
+    targets,
+    db,
+  })
+`
             );
           }
+          fs.writeFileSync(serverFilePath, updated);
+        }
+      },
+      {
+        title: "Adding environment variables to .env...",
+        task: () => {
+          addEnvVar(
+            "UPLOAD_TOKEN_SECRET",
+            generateSecret(),
+            "Signs upload tokens and file-serving URLs. Keep it secret and use a different value per environment."
+          );
+          if (wantsFs) {
+            addEnvVar(
+              "UPLOAD_SERVE_BASE_URL",
+              "http://localhost:8911",
+              "Origin the api server is reachable at, used to build signed URLs for locally stored files."
+            );
+          }
+          if (wantsS3) {
+            addEnvVar(
+              "AWS_REGION",
+              "us-east-1",
+              "Region of the uploads bucket."
+            );
+            addEnvVar("AWS_ACCESS_KEY_ID", "replace-me", "");
+            addEnvVar("AWS_SECRET_ACCESS_KEY", "replace-me", "");
+            addEnvVar(
+              "S3_BUCKET_UPLOADS",
+              "replace-me",
+              "Bucket direct uploads land in."
+            );
+          }
+        }
+      },
+      {
+        title: "Adding the fs upload directory to .gitignore...",
+        skip: () => wantsFs ? false : "No fs target selected; skipping.",
+        task: (_ctx, task) => {
+          const gitignorePath = path.join(paths.base, ".gitignore");
+          const source = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, "utf-8") : "";
+          const updated = transformGitignore(source);
+          if (updated === source) {
+            task.skip(".gitignore already up to date");
+            return;
+          }
+          fs.writeFileSync(gitignorePath, updated, "utf-8");
         }
       },
       {
         title: "Prettifying changed files",
         task: async (_ctx, task) => {
           const prettifyPaths = [
-            path.join(getPaths().api.lib, "db.js"),
-            path.join(getPaths().api.lib, "db.ts"),
-            path.join(getPaths().api.lib, "uploads.js"),
-            path.join(getPaths().api.lib, "uploads.ts")
+            serverFilePath,
+            path.join(paths.api.lib, `uploads.${ext}`),
+            path.join(paths.api.graphql, `uploads.sdl.${ext}`),
+            path.join(paths.api.services, "uploads", `uploads.${ext}`)
           ];
           for (const prettifyPath of prettifyPaths) {
             try {
@@ -108,11 +301,11 @@ const handler = async ({ force }) => {
               }
               const source = fs.readFileSync(prettifyPath, "utf-8");
               const prettierOptions = await getPrettierOptions();
-              const prettifiedApp = await format(source, {
+              const prettified = await format(source, {
                 ...prettierOptions,
                 parser: "babel-ts"
               });
-              fs.writeFileSync(prettifyPath, prettifiedApp, "utf-8");
+              fs.writeFileSync(prettifyPath, prettified, "utf-8");
             } catch {
               task.output = "Couldn't prettify the changes. Please reformat the files manually if needed.";
             }
@@ -122,15 +315,30 @@ const handler = async ({ force }) => {
       {
         title: "One more thing...",
         task: (_ctx, task) => {
+          const migrate = c.highlight(
+            formatCedarCommand(["prisma", "migrate", "dev"])
+          );
+          const types = c.highlight(formatCedarCommand(["generate", "types"]));
           task.title = `One more thing...
 
-          ${c.success("\nUploads and storage configured!\n")}
+          ${c.success("Uploads configured!")}
+
+          Next steps:
 
-          Remember to add UPLOADS_SECRET to your .env file. You can generate one with ${c.highlight(formatCedarCommand(["generate", "secret"]))}
+            1. Apply the schema change: ${migrate}
+            2. Regenerate types: ${types}
+            3. Review the storage targets and upload profiles in api/src/lib/uploads.${ext}${wantsS3 ? "\n            4. Fill in the AWS_* and S3_BUCKET_UPLOADS values in .env" : ""}
+
+          Upload tokens are bound to the logged-in user when the app has auth.
+          If you add auth later, pass
+          \`authenticate: createUploadAuthenticator({ authDecoder, getCurrentUser })\`
+          to the plugin in api/src/server.${ext}.
+
+          Schedule cleanupStaleUploads() from a recurring job to sweep uploads
+          that never completed.
 
           Check out the docs for more info:
           ${terminalLink("", "https://cedarjs.com/docs/uploads")}
-
         `;
         }
       }

package/dist/commands/setup.js

@@ -16,11 +16,12 @@ import * as setupNeon from "./setup/neon/neon.js";
 import * as setupPackage from "./setup/package/package.js";
 import * as setupRealtime from "./setup/realtime/realtime.js";
 import * as setupServerFile from "./setup/server-file/serverFile.js";
+import * as setupTenancy from "./setup/tenancy/tenancy.js";
 import * as setupUi from "./setup/ui/ui.js";
 import * as setupUploads from "./setup/uploads/uploads.js";
 const command = "setup <command>";
 const description = "Initialize project config and install packages";
-const builder = (yargs) => yargs.command(setupAuth).command(setupCache).command(setupDatabase).command(setupDeploy).command(setupDocker).command(setupGenerator).command(setupGraphql).command(setupI18n).command(setupJobs).command(setupMailer).command(setupMiddleware).command(setupMonitoring).command(setupNeon).command(setupPackage).command(setupRealtime).command(setupServerFile).command(setupUi).command(setupUploads).demandCommand().middleware(detectCedarVersion).epilogue(
+const builder = (yargs) => yargs.command(setupAuth).command(setupCache).command(setupDatabase).command(setupDeploy).command(setupDocker).command(setupGenerator).command(setupGraphql).command(setupI18n).command(setupJobs).command(setupMailer).command(setupMiddleware).command(setupMonitoring).command(setupNeon).command(setupPackage).command(setupRealtime).command(setupServerFile).command(setupTenancy).command(setupUi).command(setupUploads).demandCommand().middleware(detectCedarVersion).epilogue(
   `Also see the ${terminalLink(
     "CedarJS CLI Reference",
     "https://cedarjs.com/docs/cli-commands#setup"

package/dist/commands/studio.js

@@ -1,4 +1,4 @@
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 const command = "studio";
 const description = "Run the CedarJS development studio";
 function builder(yargs) {