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

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

@@ -1,16 +1,25 @@
 import path from "node:path";
 import camelcase from "camelcase";
-import { pluralize, singularize } from "../../../lib/cedarPluralize.js";
+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;
+}
 const DEFAULT_SCENARIO_NAMES = ["one", "two"];
 const parseSchema = async (model) => {
-  const schema = await getSchema(model);
+  const schemaResult = await getSchema(model);
+  if (!isServiceModel(schemaResult)) {
+    throw new Error(
+      `No schema definition found for \`${model}\` in schema.prisma file`
+    );
+  }
+  const schema = schemaResult;
   const relations = {};
   let foreignKeys = [];
-  let scalarFields = schema.fields.filter((field) => {
+  const scalarFields = schema.fields.filter((field) => {
     if (field.relationFromFields) {
       if (field.isRequired && field.relationFromFields.length !== 0) {
         relations[field.name] = {
@@ -23,15 +32,18 @@ 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;
-  const randInt = parseInt(Math.random() * 1e7);
+  const randInt = parseInt(String(Math.random() * 1e7));
   const randIntArray = [
-    parseInt(Math.random() * 300),
-    parseInt(Math.random() * 300),
-    parseInt(Math.random() * 300)
+    parseInt(String(Math.random() * 300)),
+    parseInt(String(Math.random() * 300)),
+    parseInt(String(Math.random() * 300))
   ];
   switch (field.type) {
     case "BigInt":
@@ -55,11 +67,12 @@ function scenarioFieldValue(field) {
     case "Bytes":
       return `new Uint8Array([${randIntArray}])`;
     default: {
-      if (field.kind === "enum" && field.enumValues[0]) {
+      if (field.kind === "enum" && field.enumValues?.[0]) {
         return field.enumValues[0].dbName || field.enumValues[0].name;
       }
     }
   }
+  return void 0;
 }
 const fieldsToScenario = async (scalarFields, relations, foreignKeys) => {
   const data = {};
@@ -126,15 +139,23 @@ const buildStringifiedScenario = async (model) => {
 };
 const fieldTypes = async (model) => {
   const { scalarFields } = await parseSchema(model);
-  return scalarFields.reduce((acc, value) => {
-    acc[value.name] = value.type;
-    return acc;
-  }, {});
+  return scalarFields.reduce(
+    (acc, value) => {
+      acc[value.name] = value.type;
+      return acc;
+    },
+    {}
+  );
 };
 const fieldsToInput = async (model) => {
-  const { scalarFields, foreignKeys } = await parseSchema(model);
+  const { scalarFields, foreignKeys, redactedFields } = await parseSchema(model);
   const modelName = camelcase(singularize(model));
-  let inputObj = {};
+  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}`;
@@ -149,12 +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((scalar) => !foreignKeys.includes(scalar.name));
+  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;
@@ -168,25 +194,31 @@ const fieldsToUpdate = async (model) => {
     newValue = value;
     switch (field.type) {
       case "BigInt":
-        newValue = `${newValue + 1n}`;
+        if (typeof value === "bigint") {
+          newValue = `${value + 1n}`;
+        }
         break;
       case "Boolean": {
         newValue = !value;
         break;
       }
       case "DateTime": {
-        let date = /* @__PURE__ */ new Date();
+        const date = /* @__PURE__ */ new Date();
         date.setDate(date.getDate() + 1);
         newValue = date;
         break;
       }
       case "Decimal":
       case "Float": {
-        newValue = newValue + 1.1;
+        if (typeof value === "number") {
+          newValue = value + 1.1;
+        }
         break;
       }
       case "Int": {
-        newValue = newValue + 1;
+        if (typeof value === "number") {
+          newValue = value + 1;
+        }
         break;
       }
       case "Json": {
@@ -194,11 +226,13 @@ const fieldsToUpdate = async (model) => {
         break;
       }
       case "String": {
-        newValue = newValue + "2";
+        if (typeof value === "string") {
+          newValue = value + "2";
+        }
         break;
       }
       default: {
-        if (field.kind === "enum" && field.enumValues[field.enumValues.length - 1]) {
+        if (field.kind === "enum" && field.enumValues?.[field.enumValues.length - 1]) {
           const enumVal = field.enumValues[field.enumValues.length - 1];
           newValue = enumVal.dbName || enumVal.name;
         }
@@ -206,11 +240,21 @@ const fieldsToUpdate = async (model) => {
       }
     }
   }
+  if (Array.isArray(fieldName)) {
+    return Object.fromEntries(fieldName.map((key) => [key, newValue]));
+  }
   return { [fieldName]: newValue };
 };
 const getIdName = async (model) => {
-  const schema = await getSchema(model);
-  return schema.fields.find((field) => field.isId)?.name;
+  const schemaResult = await getSchema(model);
+  if (!isServiceModel(schemaResult)) {
+    return void 0;
+  }
+  if (schemaResult.primaryKey?.fields.length) {
+    const { fields, name } = schemaResult.primaryKey;
+    return { fields, whereArg: name || fields.join("_") };
+  }
+  return schemaResult.fields.find((field) => field.isId)?.name;
 };
 const files = async ({
   name,
@@ -222,7 +266,21 @@ const files = async ({
   const componentName = camelcase(pluralize(name));
   const model = name;
   const idName = await getIdName(model);
-  const modelRelations = relations || relationsForModel(await getSchema(model));
+  if (tests && rest.crud && idName !== void 0 && typeof idName !== "string") {
+    throw new Error(
+      `Cannot generate CRUD tests for "${model}": it has a compound primary key (@@id([${idName.fields.join(", ")}])), which isn't supported by the generated test file yet. Re-run with \`--tests=false\`.`
+    );
+  }
+  const prismaImportSource = "src/lib/db";
+  let modelRelations;
+  if (relations) {
+    modelRelations = relations;
+  } else {
+    const schemaResult = await getSchema(model);
+    if (isServiceModel(schemaResult)) {
+      modelRelations = relationsForModel(schemaResult);
+    }
+  }
   const serviceFile = await templateForFile({
     name,
     side: "api",
@@ -230,46 +288,53 @@ const files = async ({
     generator: "service",
     outputPath: path.join(componentName, componentName + ".ts"),
     templatePath: "service.ts.template",
-    templateVars: { relations: modelRelations, idName, ...rest }
-  });
-  const testFile = await templateForFile({
-    name,
-    side: "api",
-    sidePathSection: "services",
-    generator: "service",
-    outputPath: path.join(componentName, componentName + ".test.ts"),
-    templatePath: "test.ts.template",
     templateVars: {
-      relations: relations || [],
-      create: await fieldsToInput(model),
-      update: await fieldsToUpdate(model),
-      types: await fieldTypes(model),
-      prismaImport: (await parseSchema(model)).scalarFields.some(
-        (field) => field.type === "Decimal"
-      ),
-      prismaModel: model,
-      idName,
-      ...rest
-    }
-  });
-  const scenariosFile = await templateForFile({
-    name,
-    side: "api",
-    sidePathSection: "services",
-    generator: "service",
-    outputPath: path.join(componentName, componentName + ".scenarios.ts"),
-    templatePath: "scenarios.ts.template",
-    templateVars: {
-      scenario: await buildScenario(model),
-      stringifiedScenario: await buildStringifiedScenario(model),
-      prismaModel: model,
-      idName,
       relations: modelRelations,
+      idName,
+      prismaImportSource,
       ...rest
     }
   });
   const files2 = [serviceFile];
   if (tests) {
+    const testFile = await templateForFile({
+      name,
+      side: "api",
+      sidePathSection: "services",
+      generator: "service",
+      outputPath: path.join(componentName, componentName + ".test.ts"),
+      templatePath: "test.ts.template",
+      templateVars: {
+        relations: relations || [],
+        create: await fieldsToInput(model),
+        update: await fieldsToUpdate(model),
+        types: await fieldTypes(model),
+        prismaImport: (await parseSchema(model)).scalarFields.some(
+          (field) => field.type === "Decimal"
+        ),
+        prismaModel: model,
+        idName,
+        prismaImportSource,
+        ...rest
+      }
+    });
+    const scenariosFile = await templateForFile({
+      name,
+      side: "api",
+      sidePathSection: "services",
+      generator: "service",
+      outputPath: path.join(componentName, componentName + ".scenarios.ts"),
+      templatePath: "scenarios.ts.template",
+      templateVars: {
+        scenario: await buildScenario(model),
+        stringifiedScenario: await buildStringifiedScenario(model),
+        prismaModel: model,
+        idName,
+        relations: modelRelations,
+        prismaImportSource,
+        ...rest
+      }
+    });
     files2.push(testFile);
     files2.push(scenariosFile);
   }

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

@@ -1,6 +1,8 @@
-import type { Prisma, ${prismaModel} } from '@prisma/client'
+<% if (prismaImportSource === 'src/lib/db') { %>import type { ScenarioData } from '@cedarjs/testing/api'
 
-import type { ScenarioData } from '@cedarjs/testing/api'
+import type { Prisma, ${prismaModel} } from '${prismaImportSource}'<% } else { %>import type { Prisma, ${prismaModel} } from '${prismaImportSource}'
+
+import type { ScenarioData } from '@cedarjs/testing/api'<% } %>
 
 export const standard = defineScenario<Prisma.${prismaModel}CreateArgs>(${stringifiedScenario})
 

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

@@ -1,14 +1,28 @@
 import type { QueryResolvers<% if (crud) { %>, MutationResolvers<% } %><% if (relations.length) { %>, ${singularPascalName}RelationResolvers<% } %> } from 'types/graphql'
 
 import { db } from 'src/lib/db'
-
+<%
+  // A compound `@@id([...])` key comes through as `{ fields, whereArg }`
+  // instead of a single field name -- build the destructure/where-clause
+  // snippets for both shapes here so the rest of the template can stay
+  // shape-agnostic.
+  const idIsComposite = idName != null && typeof idName === 'object'
+  const idFields = idIsComposite ? idName.fields : [idName]
+  const idArgs = idFields.join(', ')
+  const idWhere = idIsComposite
+    ? `${idName.whereArg}: { ${idFields.join(', ')} }`
+    : idName
+  const idWhereFromRoot = idIsComposite
+    ? `${idName.whereArg}: { ${idFields.map((f) => `${f}: root?.${f}`).join(', ')} }`
+    : `${idName}: root?.${idName}`
+%>
 export const ${pluralCamelName}: QueryResolvers['${pluralCamelName}'] = () => {
   return db.${singularCamelName}.findMany()
 }<% if (crud || relations.length) { %>
 
-export const ${singularCamelName}: QueryResolvers['${singularCamelName}'] = ({ ${idName} }) => {
+export const ${singularCamelName}: QueryResolvers['${singularCamelName}'] = ({ ${idArgs} }) => {
   return db.${singularCamelName}.findUnique({
-    where: { ${idName} },
+    where: { ${idWhere} },
   })
 }<% } %><% if (crud) { %>
 
@@ -18,21 +32,21 @@ export const create${singularPascalName}: MutationResolvers['create${singularPas
   })
 }
 
-export const update${singularPascalName}: MutationResolvers['update${singularPascalName}'] = ({ ${idName}, input }) => {
+export const update${singularPascalName}: MutationResolvers['update${singularPascalName}'] = ({ ${idArgs}, input }) => {
   return db.${singularCamelName}.update({
     data: input,
-    where: { ${idName} },
+    where: { ${idWhere} },
   })
 }
 
-export const delete${singularPascalName}: MutationResolvers['delete${singularPascalName}'] = ({ ${idName} }) => {
+export const delete${singularPascalName}: MutationResolvers['delete${singularPascalName}'] = ({ ${idArgs} }) => {
   return db.${singularCamelName}.delete({
-    where: { ${idName} },
+    where: { ${idWhere} },
   })
 }<% } %><% if (relations.length) { %>
 
 export const ${singularPascalName}: ${singularPascalName}RelationResolvers = {<% relations.forEach(relation => { %>
   ${relation}: (_obj, { root }) => {
-    return db.${singularCamelName}.findUnique({ where: { ${idName}: root?.${idName} } }).${relation}()
+    return db.${singularCamelName}.findUnique({ where: { ${idWhereFromRoot} } }).${relation}()
   },<% }) %>
 }<% } %>

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

@@ -31,7 +31,7 @@
     // Not all values can be represented as JSON, like function invocations
     return jsonString.replace(/"new Uint8Array\(([^)]+)\)"/g, 'new Uint8Array($1)')
   } %>
-<% if (prismaImport) { %>import { Prisma, ${prismaModel} } from '@prisma/client'<% } else { %>import type { ${prismaModel} } from '@prisma/client'<% } %>
+<% if (prismaImport) { %>import { Prisma, ${prismaModel} } from '${prismaImportSource}'<% } else { %>import type { ${prismaModel} } from '${prismaImportSource}'<% } %>
 
 import { ${pluralCamelName}<% if (crud) { %>,${singularCamelName}, create${singularPascalName}, update${singularPascalName}, delete${singularPascalName}<% } %> } from './${pluralCamelName}.js'
 import type { StandardScenario } from './${pluralCamelName}.scenarios.js'
@@ -40,7 +40,7 @@ import type { StandardScenario } from './${pluralCamelName}.scenarios.js'
 // and can fail without adjustments, e.g. Float.
 //           Please refer to the RedwoodJS Testing Docs:
 //       https://cedarjs.com/docs/testing#testing-services
-// https://cedarjs.com/docs/testing#jest-expect-type-considerations
+// https://cedarjs.com/docs/testing#expect-type-considerations
 
 describe('${pluralCamelName}', () => {
   scenario('returns all ${pluralCamelName}', async (scenario: StandardScenario) => {

package/dist/commands/generate/yargsCommandHelpers.js

@@ -1,5 +1,5 @@
 import { terminalLink } from "termi-link";
-import { isTypeScriptProject } from "@cedarjs/cli-helpers";
+import { isTypeScriptProject } from "@cedarjs/cli-helpers/project";
 function getYargsDefaults() {
   return {
     force: {
@@ -70,11 +70,16 @@ function createBuilder({
     Object.entries(opts).forEach(([option, config]) => {
       yargs.option(option, config);
     });
+    return yargs;
   };
 }
 function createHandler(componentName) {
   return async function handler(argv) {
-    const { handler: importedHandler } = await import(`./${componentName}/${componentName}Handler.js`);
+    const { existsSync } = await import("node:fs");
+    const tsPath = `./${componentName}/${componentName}Handler.ts`;
+    const jsPath = `./${componentName}/${componentName}Handler.js`;
+    const resolvedPath = existsSync(new URL(tsPath, import.meta.url)) ? tsPath : jsPath;
+    const { handler: importedHandler } = await import(resolvedPath);
     return importedHandler(argv);
   };
 }

package/dist/commands/generate/yargsHandlerHelpers.js

@@ -3,10 +3,10 @@ import path from "node:path";
 import { camelCase } from "change-case";
 import { Listr } from "listr2";
 import pascalcase from "pascalcase";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { ensurePosixPath, getConfig } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import c from "../../lib/colors.js";
 import { generateTemplate, getPaths, writeFilesTask } from "../../lib/index.js";
 import { prepareForRollback } from "../../lib/rollback.js";
 import {
@@ -31,14 +31,8 @@ const customOrDefaultTemplatePath = ({
     generator,
     templatePath
   );
-  const deprecatedCustomPath = getPaths()[side].generators ? path.join(getPaths()[side].generators, generator, templatePath) : void 0;
   if (fs.existsSync(customPath)) {
     return customPath;
-  } else if (deprecatedCustomPath && fs.existsSync(deprecatedCustomPath)) {
-    console.log(
-      `Having generator templates in ${getPaths()[side].generators} has been deprecated. Please move them to ${getPaths().generatorTemplates}.`
-    );
-    return deprecatedCustomPath;
   } else {
     return defaultPath;
   }
@@ -52,7 +46,11 @@ const templateForFile = async ({
   templatePath,
   templateVars
 }) => {
-  const basePath = sidePathSection ? getPaths()[side][sidePathSection] : getPaths()[side];
+  const paths = getPaths();
+  const basePath = side === "scripts" ? paths.scripts : side === "web" ? sidePathSection ? paths.web[sidePathSection] : paths.web.base : side === "packages" ? paths.packages : sidePathSection ? paths.api[sidePathSection] : paths.api.base;
+  if (typeof basePath !== "string") {
+    throw new Error(`Invalid path section: "${sidePathSection}"`);
+  }
   const fullOutputPath = path.join(basePath, outputPath);
   const fullTemplatePath = customOrDefaultTemplatePath({
     generator,
@@ -127,6 +125,10 @@ function createHandler({
     validateName(argv.name);
     try {
       argv = await preTasksFn(argv);
+      const listrOptions = {
+        exitOnError: true,
+        ...argv.verbose ? { renderer: "verbose" } : { rendererOptions: { collapseSubtasks: false } }
+      };
       const tasks = new Listr(
         [
           {
@@ -138,28 +140,28 @@ function createHandler({
           },
           ...includeAdditionalTasks(argv)
         ],
-        {
-          rendererOptions: { collapseSubtasks: false },
-          exitOnError: true,
-          renderer: argv.verbose && "verbose"
-        }
+        listrOptions
       );
       if (argv.rollback && !argv.force) {
         prepareForRollback(tasks);
       }
       await tasks.run();
     } 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);
+      errorTelemetry(process.argv, message);
+      console.error(c.error(message));
+      process.exit(errorExitCode(e));
     }
   };
 }
+function errorExitCode(e) {
+  return typeof e === "object" && e !== null && "exitCode" in e && typeof e.exitCode === "number" ? e.exitCode : 1;
+}
 const createYargsForComponentGeneration = ({
   componentName,
   preTasksFn = (options) => options,
   /** filesFn is not used if generator implements its own `handler` */
-  filesFn = () => ({}),
+  filesFn = async () => ({}),
   optionsObj,
   positionalsObj = {},
   /** function that takes the options object and returns an array of listr tasks */

package/dist/commands/generate.js

@@ -1,6 +1,6 @@
-import execa from "execa";
 import { terminalLink } from "termi-link";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { runBinSync } from "@cedarjs/cli-helpers/packageManager/exec";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import * as generateCell from "./generate/cell/cell.js";
 import * as generateComponent from "./generate/component/component.js";
 import * as generateDataMigration from "./generate/dataMigration/dataMigration.js";
@@ -25,9 +25,9 @@ const description = "Generate boilerplate code and type definitions";
 const builder = (yargs) => yargs.command("types", "Generate supplementary code", {}, () => {
   recordTelemetryAttributes({ command: "generate types" });
   try {
-    execa.sync("yarn", ["rw-gen"], { stdio: "inherit" });
+    runBinSync("cedar-gen", [], { stdio: "inherit" });
   } catch (error) {
-    process.exitCode = error.exitCode ?? 1;
+    process.exitCode = typeof error === "object" && error !== null && "exitCode" in error && typeof error.exitCode === "number" ? error.exitCode : 1;
   }
 }).command(generateCell).command(generateComponent).command(generateDataMigration).command(generateDbAuth).command(generateDirective).command(generateFunction).command(generateJob).command(generateLayout).command(generateModel).command(generateOgImage).command(generatePackage).command(generatePage).command(generateRealtime).command(generateScaffold).command(generateScript).command(generateSdl).command(generateSecret).command(generateService).demandCommand().epilogue(
   `Also see the ${terminalLink(

package/dist/commands/info.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import envinfo from "envinfo";
 import { terminalLink } from "termi-link";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { getConfigPath } from "@cedarjs/project-config";
 const command = "info";
 const description = "Print your system environment information";
@@ -28,7 +28,7 @@ const handler = async () => {
   const tomlContent = fs.readFileSync(configTomlPath, "utf8");
   console.log(
     output + `  ${path.basename(configTomlPath)}:
-` + tomlContent.split("\n").filter((line) => line.trim().length > 0).filter((line) => !/^#/.test(line)).map((line) => `    ${line}`).join("\n")
+` + tomlContent.split("\n").filter((line) => line.trim().length > 0).filter((line) => !line.startsWith("#")).map((line) => `    ${line}`).join("\n")
   );
 };
 export {

package/dist/commands/jobsHandler.js

@@ -1,4 +1,5 @@
 import execa from "execa";
+import { formatRunBinCommand } from "@cedarjs/cli-helpers/packageManager/display";
 import { getPaths } from "../lib/index.js";
 const handler = async ({
   _,
@@ -6,16 +7,18 @@ const handler = async ({
   commands: _commands,
   ...options
 }) => {
-  const args = [_.pop()];
+  const positionalArgs = Array.isArray(_) ? [..._] : [];
+  const commandArg = positionalArgs.pop();
+  const args = [commandArg == null ? "" : String(commandArg)];
   for (const [name, value] of Object.entries(options)) {
     args.push(name.length > 1 ? `--${name}` : `-${name}`);
-    args.push(value);
+    args.push(String(value));
   }
-  let command = `yarn rw-jobs ${args.join(" ")}`;
+  let command = formatRunBinCommand("cedar-jobs", args);
   const originalLogLevel = process.env.LOG_LEVEL;
   process.env.LOG_LEVEL = originalLogLevel || "warn";
   if (process.env.NODE_ENV !== "production") {
-    command += " | yarn rw-log-formatter";
+    command += ` | ${formatRunBinCommand("cedar-log-formatter")}`;
     process.env.LOG_LEVEL = originalLogLevel || "debug";
   }
   execa.commandSync(command, {