@cedarjs/cli 6.0.0-rc.189 → 6.0.0-rc.241

package/dist/commands/dev.js

@@ -13,10 +13,7 @@ const builder = (yargs) => {
   }).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
+    type: "string"
   }).option("generate", {
     type: "boolean",
     default: true,

package/dist/commands/experimental/setupOpentelemetryHandler.js

@@ -114,7 +114,7 @@ const handler = async ({
       },
       task: (_ctx, task) => {
         task.output = [
-          "Please add the following to your 'redwoodFastifyGraphQLServer' plugin options to enable OTel for your graphql",
+          "Please add the following to your 'cedarFastifyGraphQLServer' plugin options to enable OTel for your graphql",
           "openTelemetryOptions: {",
           "  resolvers: true,",
           "  result: true,",

package/dist/commands/generate/helpers.js

@@ -23,6 +23,20 @@ const validateName = (name) => {
     );
   }
 };
+const SENSITIVE_FIELDS = [
+  "hashedPassword",
+  "salt",
+  "resetToken",
+  "resetTokenExpiresAt",
+  "webAuthnChallenge"
+];
+const redactedModelFields = (fieldNames) => {
+  const sensitive = fieldNames.filter((name) => SENSITIVE_FIELDS.includes(name));
+  if (sensitive.length === 1 && sensitive[0] === "salt") {
+    return [];
+  }
+  return sensitive;
+};
 const relationsForModel = (model) => {
   return model?.fields.filter((f) => f.relationName).map((field) => {
     return field.name;
@@ -60,11 +74,13 @@ const mapPrismaScalarToPagePropTsType = (scalarType) => {
   return prismaScalarToTsType[scalarType] || "unknown";
 };
 export {
+  SENSITIVE_FIELDS,
   forcePluralizeWord,
   intForeignKeysForModel,
   mapPrismaScalarToPagePropTsType,
   mapRouteParamTypeToTsType,
   pathName,
+  redactedModelFields,
   relationsForModel,
   removeGeneratorName,
   validateName

package/dist/commands/generate/scaffold/scaffoldHandler.js

@@ -19,7 +19,6 @@ import {
   writeFile,
   getDefaultArgs,
   getPaths,
-  writeFilesTask,
   addRoutesToRouterTask,
   addScaffoldImport,
   transformTSToJS,
@@ -31,17 +30,24 @@ import {
 } from "../../../lib/rollback.js";
 import { getSchema, verifyModelName } from "../../../lib/schemaHelpers.js";
 import {
+  redactedModelFields,
   relationsForModel,
   intForeignKeysForModel,
   mapPrismaScalarToPagePropTsType
 } from "../helpers.js";
 import { builder as sdlBuilder } from "../sdl/sdl.js";
-import { files as sdlFiles } from "../sdl/sdlHandler.js";
+import {
+  files as sdlFiles,
+  printRedactedFieldsNote,
+  redactedSensitiveFields
+} from "../sdl/sdlHandler.js";
+import { writeFilesWithStubsTask } from "../sdl/stubFiles.js";
 import { builder as serviceBuilder } from "../service/service.js";
 import { files as serviceFiles } from "../service/serviceHandler.js";
 import { customOrDefaultTemplatePath } from "../yargsHandlerHelpers.js";
 const SKIPPABLE_ASSETS = ["scaffold.css"];
 const PACKAGE_SET = "Set";
+const PACKAGE_PRIVATE_SET = "PrivateSet";
 const getIdType = (model) => {
   return model.fields.find((field) => field.isId)?.type;
 };
@@ -272,7 +278,10 @@ const modelRelatedVariables = (model) => {
     }
   };
   const relations = relationsForModel(model)?.map((relation) => relation);
-  const columns = model.fields.filter((field) => field.kind !== "object").map((column) => {
+  const redactedFields = redactedModelFields(
+    model.fields.map((field) => field.name)
+  );
+  const columns = model.fields.filter((field) => field.kind !== "object").filter((field) => !redactedFields.includes(field.name)).map((column) => {
     let validation;
     const meta = componentMetadata[column.type];
     const validationDef = meta?.validation;
@@ -512,6 +521,65 @@ const addHelperPackages = async (task) => {
     await removeWorkspacePackages("web", ["humanize-string"]);
   });
 };
+const isAuthSetup = () => {
+  const extensions = ["ts", "js", "tsx", "jsx"];
+  return extensions.some(
+    (ext) => fs.existsSync(path.join(getPaths().web.src, "auth." + ext))
+  );
+};
+const ROUTE_TAG_RE = /<Route\s+([^>]*?)\/?>/g;
+const extractRouteAttr = (tagAttrs, attrName) => tagAttrs.match(new RegExp(`\\b${attrName}=["']([^"']+)["']`))?.[1];
+const getRoutesFileContent = () => {
+  const routesPath = getPaths().web.routes;
+  if (!fs.existsSync(routesPath)) {
+    return void 0;
+  }
+  return readFile(routesPath).toString();
+};
+const hasLoginRoute = () => {
+  const content = getRoutesFileContent();
+  if (!content) {
+    return false;
+  }
+  return Array.from(content.matchAll(ROUTE_TAG_RE)).some(
+    ([, attrs]) => extractRouteAttr(attrs, "name") === "login"
+  );
+};
+const findUnprotectedLandingPageRouteName = () => {
+  const content = getRoutesFileContent();
+  if (!content) {
+    return void 0;
+  }
+  const privateSetRanges = Array.from(
+    content.matchAll(/<PrivateSet\b[^>]*>([\s\S]*?)<\/PrivateSet>/g)
+  ).map((match) => ({
+    start: match.index ?? 0,
+    end: (match.index ?? 0) + match[0].length
+  }));
+  for (const match of content.matchAll(ROUTE_TAG_RE)) {
+    const [, attrs] = match;
+    if (extractRouteAttr(attrs, "path") !== "/") {
+      continue;
+    }
+    const tagStart = match.index ?? 0;
+    const isProtected = privateSetRanges.some(
+      (range) => tagStart >= range.start && tagStart < range.end
+    );
+    if (!isProtected) {
+      return extractRouteAttr(attrs, "name");
+    }
+  }
+  return void 0;
+};
+const getUnauthenticatedRedirectRoute = () => {
+  if (!isAuthSetup()) {
+    return void 0;
+  }
+  if (hasLoginRoute()) {
+    return "login";
+  }
+  return findUnprotectedLandingPageRouteName();
+};
 const addSetImport = (task) => {
   const routesPath = getPaths().web.routes;
   const routesContent = readFile(routesPath).toString();
@@ -525,15 +593,19 @@ const addSetImport = (task) => {
     return void 0;
   }
   const routerImports = importContent.replace(/\s/g, "").split(",");
-  if (routerImports.includes(PACKAGE_SET)) {
+  const namesToImport = [
+    PACKAGE_SET,
+    ...getUnauthenticatedRedirectRoute() ? [PACKAGE_PRIVATE_SET] : []
+  ].filter((name) => !routerImports.includes(name));
+  if (!namesToImport.length) {
     return "Skipping Set import";
   }
   const newRoutesContent = routesContent.replace(
     cedarRouterImport,
-    importStart + spacing + PACKAGE_SET + `,` + spacing + importContent + importEnd
+    importStart + spacing + namesToImport.join("," + spacing) + `,` + spacing + importContent + importEnd
   );
   writeFile(routesPath, newRoutesContent, { overwriteExisting: true });
-  return "Added Set import to Routes.{jsx,tsx}";
+  return `Added ${namesToImport.join(", ")} import to Routes.{jsx,tsx}`;
 };
 const addScaffoldSetToRouter = async (model, scaffoldPath) => {
   const templateNames = getTemplateStrings(model, scaffoldPath);
@@ -542,10 +614,12 @@ const addScaffoldSetToRouter = async (model, scaffoldPath) => {
   const titleTo = templateNames.pluralRouteName;
   const buttonLabel = `New ${nameVars.singularPascalName}`;
   const buttonTo = templateNames.newRouteName;
+  const unauthenticatedRoute = getUnauthenticatedRedirectRoute();
   return addRoutesToRouterTask(
     await routes({ model, path: scaffoldPath }),
     "ScaffoldLayout",
-    { title, titleTo, buttonLabel, buttonTo }
+    { title, titleTo, buttonLabel, buttonTo },
+    unauthenticatedRoute ? { unauthenticated: unauthenticatedRoute } : void 0
   );
 };
 const tasks = ({
@@ -572,7 +646,7 @@ const tasks = ({
             tailwind,
             force
           });
-          return writeFilesTask(f, { overwriteExisting: force });
+          return writeFilesWithStubsTask(f, { overwriteExisting: force });
         }
       },
       {
@@ -650,6 +724,7 @@ const handler = async ({
       prepareForRollback(t);
     }
     await t.run();
+    printRedactedFieldsNote(await redactedSensitiveFields([name]));
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
     const exitCode = e instanceof Error && "exitCode" in e ? e.exitCode ?? 1 : 1;
@@ -664,7 +739,10 @@ const splitPathAndModel = (pathSlashModel) => {
 };
 export {
   files,
+  getUnauthenticatedRedirectRoute,
   handler,
+  hasLoginRoute,
+  isAuthSetup,
   routes,
   shouldUseTailwindCSS,
   splitPathAndModel,

package/dist/commands/generate/sdl/sdlHandler.js

@@ -3,11 +3,12 @@ import boxen from "boxen";
 import camelcase from "camelcase";
 import { Listr } from "listr2";
 import { recordTelemetryAttributes, colors as c } from "@cedarjs/cli-helpers";
+import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
 import { generate as generateTypes } from "@cedarjs/internal/dist/generate/generate";
 import { getConfig } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { pluralize } from "@cedarjs/utils/cedarPluralize";
-import { transformTSToJS, writeFilesTask } from "../../../lib/index.js";
+import { transformTSToJS } from "../../../lib/index.js";
 import {
   prepareForRollback,
   addFunctionToRollback
@@ -17,9 +18,14 @@ import {
   getEnum,
   verifyModelName
 } from "../../../lib/schemaHelpers.js";
-import { relationsForModel } from "../helpers.js";
+import { redactedModelFields, relationsForModel } from "../helpers.js";
 import { files as serviceFiles } from "../service/serviceHandler.js";
 import { templateForFile } from "../yargsHandlerHelpers.js";
+import {
+  addStubHeader,
+  missingRelatedModels,
+  writeFilesWithStubsTask
+} from "./stubFiles.js";
 const DEFAULT_IGNORE_FIELDS_FOR_INPUT = ["createdAt", "updatedAt"];
 const missingIdConsoleMessage = () => {
   const line1 = ansis.bold.yellow("WARNING") + ": Cannot generate CRUD SDL without an `@id` database column.";
@@ -63,16 +69,23 @@ const modelFieldToSDL = ({
     return fieldContent;
   }
 };
+const modelRedactedFields = (model) => {
+  return redactedModelFields(model.fields.map((field) => field.name));
+};
 const querySDL = (model, docs = false) => {
-  return model.fields.map((field) => modelFieldToSDL({ field, docs }));
+  const redactedFields = modelRedactedFields(model);
+  return model.fields.filter((field) => !redactedFields.includes(field.name)).map((field) => modelFieldToSDL({ field, docs }));
 };
 const inputSDL = (model, required, docs = false) => {
-  const ignoredFields = DEFAULT_IGNORE_FIELDS_FOR_INPUT;
+  const ignoredFields = [
+    ...DEFAULT_IGNORE_FIELDS_FOR_INPUT,
+    ...modelRedactedFields(model)
+  ];
+  const idField = model.fields.find((field) => field.isId);
+  if (idField?.default !== void 0) {
+    ignoredFields.push(idField.name);
+  }
   return model.fields.filter((field) => {
-    const idField = model.fields.find((field2) => field2.isId);
-    if (idField?.default) {
-      ignoredFields.push(idField.name);
-    }
     return !ignoredFields.includes(field.name) && field.kind !== "object";
   }).map((field) => modelFieldToSDL({ field, required, docs }));
 };
@@ -174,6 +187,55 @@ const files = async ({
     })
   };
 };
+const stubFiles = async (models, generatedFor, { docs = false, typescript }) => {
+  const generatedFiles = {};
+  for (const stubModel of models) {
+    const stubModelFiles = await files({
+      name: stubModel,
+      crud: false,
+      docs,
+      tests: false,
+      typescript
+    });
+    for (const [stubPath, stubContent] of Object.entries(stubModelFiles)) {
+      generatedFiles[stubPath] = addStubHeader({
+        content: stubContent,
+        stubModel,
+        generatedFor
+      });
+    }
+  }
+  return generatedFiles;
+};
+const redactedSensitiveFields = async (modelNames) => {
+  const redacted = [];
+  for (const modelName of modelNames) {
+    const model = await getSchema(modelName);
+    if (!model || !("fields" in model)) {
+      continue;
+    }
+    for (const fieldName of modelRedactedFields(model)) {
+      redacted.push(`${model.name}.${fieldName}`);
+    }
+  }
+  return redacted;
+};
+const printRedactedFieldsNote = (redactedFields) => {
+  if (redactedFields.length === 0) {
+    return;
+  }
+  console.log();
+  console.log(
+    c.warning(
+      `The following fields were excluded from the generated SDL because they may contain sensitive data: ${redactedFields.join(", ")}`
+    )
+  );
+  console.log(
+    c.warning(
+      "If you want to expose any of them through your GraphQL API you can add them to the SDL file manually."
+    )
+  );
+};
 const handler = async ({
   model,
   crud,
@@ -197,13 +259,21 @@ const handler = async ({
   });
   try {
     const { name } = await verifyModelName({ name: model });
+    const missingModels = await missingRelatedModels(name);
+    const redactedFields = await redactedSensitiveFields([
+      name,
+      ...missingModels
+    ]);
     const tasks = new Listr(
       [
         {
           title: "Generating SDL files...",
           task: async () => {
-            const f = await files({ name, tests, crud, typescript, docs });
-            return writeFilesTask(f, { overwriteExisting: force });
+            const f = {
+              ...await files({ name, tests, crud, typescript, docs }),
+              ...await stubFiles(missingModels, name, { typescript, docs })
+            };
+            return writeFilesWithStubsTask(f, { overwriteExisting: force });
           }
         },
         {
@@ -230,6 +300,26 @@ const handler = async ({
       prepareForRollback(tasks);
     }
     await tasks.run();
+    if (missingModels.length > 0) {
+      console.log();
+      console.log(
+        c.info(
+          `${name} has relations to models that don't have SDL files of their own yet: ${missingModels.join(", ")}`
+        )
+      );
+      console.log(
+        c.info(
+          "Read-only SDL stubs were generated for them, since GraphQL type generation fails otherwise."
+        )
+      );
+      console.log(c.info("To replace a stub with a full SDL and service, run"));
+      for (const stubModel of missingModels) {
+        console.log(
+          c.info(`  ${formatCedarCommand(["generate", "sdl", stubModel])}`)
+        );
+      }
+    }
+    printRedactedFieldsNote(redactedFields);
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
     const exitCode = e instanceof Error && "exitCode" in e && typeof e.exitCode === "number" ? e.exitCode : 1;
@@ -240,5 +330,8 @@ const handler = async ({
 };
 export {
   files,
-  handler
+  handler,
+  printRedactedFieldsNote,
+  redactedSensitiveFields,
+  stubFiles
 };

package/dist/commands/generate/sdl/stubFiles.js

@@ -0,0 +1,132 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { Listr } from "listr2";
+import { getPaths } from "@cedarjs/project-config";
+import { writeFile } from "../../../lib/index.js";
+import { getSchema } from "../../../lib/schemaHelpers.js";
+const STUB_HASH_MARKER = "@cedar-generator-stub-hash";
+const STUB_HASH_MARKER_REGEX = new RegExp(
+  `^// ${STUB_HASH_MARKER} ([0-9a-f]+)$`,
+  "m"
+);
+function stubHash(contents) {
+  return crypto.createHash("sha256").update(contents).digest("hex").slice(0, 16);
+}
+function addStubHeader({
+  content,
+  stubModel,
+  generatedFor
+}) {
+  const body = "\n\n" + content;
+  const marker = `// ${STUB_HASH_MARKER} PLACEHOLDER`;
+  const header = [
+    `// Generated as a read-only stub by \`cedar generate sdl ${generatedFor}\`,`,
+    `// because ${generatedFor} has a relation to ${stubModel}, which had no SDL yet.`,
+    `// Run \`cedar generate sdl ${stubModel}\` to replace this stub with the real thing.`,
+    `// If you edit this file, the hash below will stop matching and you'll`,
+    `// need to pass \`--force\` to overwrite it.`,
+    marker
+  ].join("\n");
+  const contentToHash = header + body;
+  const hash = stubHash(contentToHash);
+  const finalMarker = `// ${STUB_HASH_MARKER} ${hash}`;
+  return (header + body).replace(marker, finalMarker);
+}
+function isPristineStub(contents) {
+  const match = STUB_HASH_MARKER_REGEX.exec(contents);
+  if (!match) {
+    return false;
+  }
+  const contentToHash = contents.replace(
+    match[0],
+    `// ${STUB_HASH_MARKER} PLACEHOLDER`
+  );
+  return stubHash(contentToHash) === match[1];
+}
+function readExistingSdlFiles() {
+  const graphqlDir = getPaths().api.graphql;
+  if (!fs.existsSync(graphqlDir)) {
+    return [];
+  }
+  const contents = [];
+  const dirsToWalk = [graphqlDir];
+  while (dirsToWalk.length > 0) {
+    const dir = dirsToWalk.shift();
+    if (!dir) {
+      break;
+    }
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const entryPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        dirsToWalk.push(entryPath);
+      } else if (/\.sdl\.(js|ts)$/.test(entry.name)) {
+        contents.push(fs.readFileSync(entryPath, "utf-8"));
+      }
+    }
+  }
+  return contents;
+}
+async function missingRelatedModels(modelName) {
+  const existingSdls = readExistingSdlFiles();
+  const isDefined = (typeName) => existingSdls.some(
+    (sdl) => new RegExp(`\\btype\\s+${typeName}\\b`).test(sdl)
+  );
+  const seen = /* @__PURE__ */ new Set([modelName]);
+  const missing = [];
+  const queue = [modelName];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) {
+      break;
+    }
+    const model = await getSchema(current);
+    if (!model || !("fields" in model)) {
+      continue;
+    }
+    for (const field of model.fields) {
+      if (!field.relationName || seen.has(field.type)) {
+        continue;
+      }
+      seen.add(field.type);
+      queue.push(field.type);
+      if (!isDefined(field.type)) {
+        missing.push(field.type);
+      }
+    }
+  }
+  return missing;
+}
+function writeFilesWithStubsTask(files, { overwriteExisting = false } = {}) {
+  const { base } = getPaths();
+  return new Listr(
+    Object.entries(files).map(([file, contents]) => ({
+      title: `...waiting to write file \`./${path.relative(base, file)}\`...`,
+      task: (_ctx, task) => {
+        let canOverwrite = overwriteExisting;
+        if (!canOverwrite && fs.existsSync(file)) {
+          const existingContents = fs.readFileSync(file, "utf-8");
+          if (isPristineStub(existingContents)) {
+            canOverwrite = true;
+          } else if (STUB_HASH_MARKER_REGEX.test(existingContents)) {
+            throw new Error(
+              `${file} started out as a generated stub, but has since been edited. Use \`--force\` to overwrite it.`
+            );
+          }
+        }
+        return writeFile(
+          file,
+          contents,
+          { overwriteExisting: canOverwrite },
+          task
+        );
+      }
+    }))
+  );
+}
+export {
+  addStubHeader,
+  isPristineStub,
+  missingRelatedModels,
+  writeFilesWithStubsTask
+};

package/dist/commands/generate/sdl/templates/sdl.js.template

@@ -30,6 +30,7 @@ export const schema = gql`
     <% } %>${singularCamelName}(${idName}: ${idType}!): ${singularPascalName} @requireAuth<% } %>
   }
 
+  <% if (crud) { %>
   <% if (docs) { %>
   """Autogenerated input type of Input${singularPascalName}."""
   <% } %>
@@ -51,7 +52,7 @@ export const schema = gql`
   <% } %>
   input Update${singularPascalName}Input {
     ${updateInput}
-  }<% if (crud) { %>
+  }
 
   <% if (docs) { %>
   """About mutations"""

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

@@ -30,6 +30,7 @@ export const schema = gql`
     <% } %>${singularCamelName}(${idName}: ${idType}!): ${singularPascalName} @requireAuth<% } %>
   }
 
+  <% if (crud) { %>
   <% if (docs) { %>
   """Autogenerated input type of Input${singularPascalName}."""
   <% } %>
@@ -51,7 +52,7 @@ export const schema = gql`
   <% } %>
   input Update${singularPascalName}Input {
     ${updateInput}
-  }<% if (crud) { %>
+  }
 
   <% if (docs) { %>
   """About mutations"""

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

@@ -3,7 +3,7 @@ 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 { relationsForModel } from "../helpers.js";
+import { redactedModelFields, relationsForModel } from "../helpers.js";
 import { createHandler, templateForFile } from "../yargsHandlerHelpers.js";
 function isServiceModel(schema) {
   return typeof schema === "object" && schema !== null && "fields" in schema && "name" in schema;
@@ -32,7 +32,10 @@ const parseSchema = async (model) => {
     return field.isRequired && !field.hasDefaultValue && // don't include fields that the database will default
     !field.relationName;
   });
-  return { scalarFields, relations, foreignKeys };
+  const redactedFields = redactedModelFields(
+    schema.fields.map((field) => field.name)
+  );
+  return { scalarFields, relations, foreignKeys, redactedFields };
 };
 function scenarioFieldValue(field) {
   const randFloat = Math.random() * 1e7;
@@ -145,9 +148,14 @@ const fieldTypes = async (model) => {
   );
 };
 const fieldsToInput = async (model) => {
-  const { scalarFields, foreignKeys } = await parseSchema(model);
+  const { scalarFields, foreignKeys, redactedFields } = await parseSchema(model);
   const modelName = camelcase(singularize(model));
   const inputObj = {};
+  if (scalarFields.some(
+    (field) => redactedFields.includes(field.name)
+  )) {
+    return false;
+  }
   scalarFields.forEach((field) => {
     if (foreignKeys.includes(field.name)) {
       inputObj[field.name] = `scenario.${modelName}.two.${field.name}`;
@@ -162,14 +170,17 @@ const fieldsToInput = async (model) => {
   }
 };
 const fieldsToUpdate = async (model) => {
-  const { scalarFields, relations, foreignKeys } = await parseSchema(model);
+  const { scalarFields, relations, foreignKeys, redactedFields } = await parseSchema(model);
   const modelName = camelcase(singularize(model));
   let field, newValue, fieldName;
-  field = scalarFields.find(
+  const updatableFields = scalarFields.filter(
+    (scalar) => !redactedFields.includes(scalar.name)
+  );
+  field = updatableFields.find(
     (scalar) => !foreignKeys.includes(scalar.name)
   );
   if (!field) {
-    field = scalarFields[0];
+    field = updatableFields[0];
   }
   if (!field) {
     return false;

package/dist/commands/prismaHandler.js

@@ -3,7 +3,8 @@ import boxen from "boxen";
 import { recordTelemetryAttributes, colors as c } from "@cedarjs/cli-helpers";
 import {
   formatCedarCommand,
-  formatRunBinCommand
+  formatRunBinCommand,
+  formatRunTransitiveBinCommand
 } from "@cedarjs/cli-helpers/packageManager/display";
 import { runTransitiveBinSync } from "@cedarjs/cli-helpers/packageManager/exec";
 import { errorTelemetry } from "@cedarjs/telemetry";
@@ -54,10 +55,9 @@ const handler = async ({
       args.push(String(value));
     }
   }
-  const displayCommand = args.map((arg) => arg.includes(" ") ? `"${arg}"` : arg).join(" ");
   console.log();
   console.log(c.note("Running Prisma CLI..."));
-  console.log(c.underline(`$ <pm exec> prisma ${displayCommand}`));
+  console.log(c.underline(`$ ${formatRunTransitiveBinCommand("prisma", args)}`));
   console.log();
   try {
     runTransitiveBinSync("prisma", args, {