@cedarjs/cli 9.0.0-canary.1784 → 9.0.0-canary.3124

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

@@ -2,13 +2,14 @@ import ansis from "ansis";
 import boxen from "boxen";
 import camelcase from "camelcase";
 import { Listr } from "listr2";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { formatCedarCommand } from "@cedarjs/cli-helpers/packageManager/display";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { generate as generateTypes } from "@cedarjs/internal/dist/generate/generate";
 import { getConfig } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import { pluralize } from "../../../lib/cedarPluralize.js";
-import c from "../../../lib/colors.js";
-import { transformTSToJS, writeFilesTask } from "../../../lib/index.js";
+import { pluralize } from "@cedarjs/utils/cedarPluralize";
+import { transformTSToJS } from "../../../lib/index.js";
 import {
   prepareForRollback,
   addFunctionToRollback
@@ -18,9 +19,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.";
@@ -47,12 +53,8 @@ const addFieldGraphQLComment = (field, str) => {
 const modelFieldToSDL = ({
   field,
   required = true,
-  types = {},
   docs = false
 }) => {
-  if (Object.entries(types).length) {
-    field.type = field.kind === "object" ? idType(types[field.type]) : field.type;
-  }
   const prismaTypeToGraphqlType = {
     Json: "JSON",
     Decimal: "Float",
@@ -68,40 +70,45 @@ 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, types = {}, docs = false) => {
-  const ignoredFields = DEFAULT_IGNORE_FIELDS_FOR_INPUT;
+const inputSDL = (model, required, docs = false) => {
+  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 && idField.default) {
-      ignoredFields.push(idField.name);
-    }
-    return ignoredFields.indexOf(field.name) === -1 && field.kind !== "object";
-  }).map((field) => modelFieldToSDL({ field, required, types, docs }));
+    return !ignoredFields.includes(field.name) && field.kind !== "object";
+  }).map((field) => modelFieldToSDL({ field, required, docs }));
 };
-const idInputSDL = (idType2, docs) => {
+function idInputSDL(idType2, docs) {
   if (!Array.isArray(idType2)) {
     return [];
   }
-  return idType2.map(
-    (field) => modelFieldToSDL({ field, required: true, types: {}, docs })
-  );
+  return idType2.map((field) => modelFieldToSDL({ field, required: true, docs }));
+}
+const createInputSDL = (model, docs = false) => {
+  return inputSDL(model, true, docs);
 };
-const createInputSDL = (model, types = {}, docs = false) => {
-  return inputSDL(model, true, types, docs);
+const updateInputSDL = (model, docs = false) => {
+  return inputSDL(model, false, docs);
 };
-const updateInputSDL = (model, types = {}, docs = false) => {
-  return inputSDL(model, false, types, docs);
-};
-const idType = (model, crud) => {
-  if (!crud) {
+function idType(model, crud) {
+  if (!crud || !model) {
     return void 0;
   }
   if (model.primaryKey?.fields.length) {
     const { fields: fieldNames } = model.primaryKey;
-    return fieldNames.map((name) => model.fields.find((f) => f.name === name));
+    return fieldNames.map((name) => model.fields.find((f) => f.name === name)).filter((f) => f !== void 0);
   }
   const idField = model.fields.find((field) => field.isId);
   if (!idField) {
@@ -109,7 +116,7 @@ const idType = (model, crud) => {
     throw new Error("Failed: Could not generate SDL");
   }
   return idField.type;
-};
+}
 const idName = (model, crud) => {
   if (!crud) {
     return void 0;
@@ -122,13 +129,13 @@ const idName = (model, crud) => {
   return idField.name;
 };
 const sdlFromSchemaModel = async (name, crud, docs = false) => {
-  const model = await getSchema(name);
-  const types = (await Promise.all(
-    model.fields.filter((field) => field.kind === "object").map(async (field) => {
-      const model2 = await getSchema(field.type);
-      return model2;
-    })
-  )).reduce((acc, cur) => ({ ...acc, [cur.name]: cur }), {});
+  const schemaResult = await getSchema(name);
+  if (!schemaResult || !("fields" in schemaResult)) {
+    throw new Error(
+      `No schema definition found for \`${name}\` in schema.prisma file`
+    );
+  }
+  const model = schemaResult;
   const enums = (await Promise.all(
     model.fields.filter((field) => field.kind === "enum").map(async (field) => {
       const enumDef = await getEnum(field.type);
@@ -142,8 +149,8 @@ const sdlFromSchemaModel = async (name, crud, docs = false) => {
     modelName,
     modelDescription,
     query: querySDL(model, docs).join("\n    "),
-    createInput: createInputSDL(model, types, docs).join("\n    "),
-    updateInput: updateInputSDL(model, types, docs).join("\n    "),
+    createInput: createInputSDL(model, docs).join("\n    "),
+    updateInput: updateInputSDL(model, docs).join("\n    "),
     idInput: idInputSDL(idTypeRes, docs).join("\n    "),
     idType: idType(model, crud),
     idName: idName(model, crud),
@@ -181,6 +188,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,
@@ -204,13 +260,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 });
           }
         },
         {
@@ -237,13 +301,38 @@ 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) {
-    errorTelemetry(process.argv, e.message);
-    console.error(c.error(e.message));
-    process.exit(e?.exitCode || 1);
+    const message = e instanceof Error ? e.message : String(e);
+    const exitCode = e instanceof Error && "exitCode" in e && typeof e.exitCode === "number" ? e.exitCode : 1;
+    errorTelemetry(process.argv, message);
+    console.error(c.error(message));
+    process.exit(exitCode);
   }
 };
 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/secret/secret.js

@@ -1,29 +1,29 @@
 import crypto from "node:crypto";
 import { terminalLink } from "termi-link";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 const DEFAULT_LENGTH = 32;
 const generateSecret = (length = DEFAULT_LENGTH) => {
-  return crypto.randomBytes(length).toString("base64");
+  return crypto.randomBytes(Math.trunc(length)).toString("base64");
 };
 const command = "secret";
 const description = "Generates a secret key using a cryptographically-secure source of entropy";
-const builder = (yargs) => yargs.option("length", {
-  description: "Length of the generated secret",
-  type: "integer",
-  required: false,
-  default: DEFAULT_LENGTH
-}).option("raw", {
-  description: "Prints just the raw secret",
-  type: "boolean",
-  required: false,
-  default: false
-}).epilogue(
-  `Also see the ${terminalLink(
-    "CedarJS CLI Reference",
-    "https://cedarjs.com/docs/cli-commands#generate-secret"
-  )}`
-);
-const handler = ({ length, raw }) => {
+function builder(yargs) {
+  return yargs.option("length", {
+    description: "Length of the generated secret",
+    type: "number",
+    default: DEFAULT_LENGTH
+  }).option("raw", {
+    description: "Prints just the raw secret",
+    type: "boolean",
+    default: false
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "CedarJS CLI Reference",
+      "https://cedarjs.com/docs/cli-commands#generate-secret"
+    )}`
+  );
+}
+function handler({ length, raw }) {
   recordTelemetryAttributes({
     command: "generate secret",
     length,
@@ -41,7 +41,7 @@ const handler = ({ length, raw }) => {
   );
   console.info("");
   console.info("Keep it secret, keep it safe!");
-};
+}
 export {
   DEFAULT_LENGTH,
   builder,

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

@@ -5,8 +5,8 @@ import {
   createHandler,
   getYargsDefaults
 } from "../yargsCommandHelpers.js";
-const defaults = () => {
-  const defaults2 = {
+const getDefaultOptions = () => {
+  return {
     ...getYargsDefaults(),
     tests: {
       description: "Generate test files",
@@ -18,7 +18,6 @@ const defaults = () => {
       type: "boolean"
     }
   };
-  return defaults2;
 };
 const command = createCommand("service");
 const description = createDescription("service");
@@ -36,15 +35,16 @@ const builder = (yargs) => {
       "https://cedarjs.com/docs/cli-commands#generate-service"
     )}`
   );
-  Object.entries(defaults()).forEach(([option, config]) => {
+  Object.entries(getDefaultOptions()).forEach(([option, config]) => {
     yargs.option(option, config);
   });
+  return yargs;
 };
 const handler = createHandler("service");
 export {
   builder,
   command,
-  defaults,
   description,
+  getDefaultOptions,
   handler
 };