@cedarjs/cli 6.0.0-canary.2868 → 6.0.0-canary.2870

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,12 +30,18 @@ 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";
@@ -273,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;
@@ -638,7 +646,7 @@ const tasks = ({
             tailwind,
             force
           });
-          return writeFilesTask(f, { overwriteExisting: force });
+          return writeFilesWithStubsTask(f, { overwriteExisting: force });
         }
       },
       {
@@ -716,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;

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

@@ -7,7 +7,7 @@ import { generate as generateTypes } from "@cedarjs/internal/dist/generate/gener
 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 +17,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 +68,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 +186,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 +258,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 +299,24 @@ 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(`  yarn cedar 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 +327,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/cli",
-  "version": "6.0.0-canary.2868",
+  "version": "6.0.0-canary.2870",
   "description": "The CedarJS Command Line",
   "repository": {
     "type": "git",
@@ -36,17 +36,17 @@
     "@babel/preset-typescript": "7.29.7",
     "@babel/traverse": "7.29.7",
     "@babel/types": "7.29.7",
-    "@cedarjs/api-server": "6.0.0-canary.2868",
-    "@cedarjs/babel-config": "6.0.0-canary.2868",
-    "@cedarjs/cli-helpers": "6.0.0-canary.2868",
-    "@cedarjs/internal": "6.0.0-canary.2868",
-    "@cedarjs/prerender": "6.0.0-canary.2868",
-    "@cedarjs/project-config": "6.0.0-canary.2868",
-    "@cedarjs/structure": "6.0.0-canary.2868",
-    "@cedarjs/telemetry": "6.0.0-canary.2868",
-    "@cedarjs/utils": "6.0.0-canary.2868",
-    "@cedarjs/vite": "6.0.0-canary.2868",
-    "@cedarjs/web-server": "6.0.0-canary.2868",
+    "@cedarjs/api-server": "6.0.0-canary.2870",
+    "@cedarjs/babel-config": "6.0.0-canary.2870",
+    "@cedarjs/cli-helpers": "6.0.0-canary.2870",
+    "@cedarjs/internal": "6.0.0-canary.2870",
+    "@cedarjs/prerender": "6.0.0-canary.2870",
+    "@cedarjs/project-config": "6.0.0-canary.2870",
+    "@cedarjs/structure": "6.0.0-canary.2870",
+    "@cedarjs/telemetry": "6.0.0-canary.2870",
+    "@cedarjs/utils": "6.0.0-canary.2870",
+    "@cedarjs/vite": "6.0.0-canary.2870",
+    "@cedarjs/web-server": "6.0.0-canary.2870",
     "@listr2/prompt-adapter-enquirer": "4.3.0",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/core": "1.30.1",
@@ -94,7 +94,7 @@
     "yargs": "17.7.3"
   },
   "devDependencies": {
-    "@cedarjs/framework-tools": "6.0.0-canary.2868",
+    "@cedarjs/framework-tools": "6.0.0-canary.2870",
     "@prisma/dmmf": "7.8.0",
     "@types/archiver": "^7.0.0",
     "memfs": "4.64.0",