@cedarjs/cli 4.2.1-next.0 → 4.2.1-next.269

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

@@ -1,6 +1,6 @@
 import { terminalLink } from "termi-link";
 import { createHandler, getYargsDefaults } from "../yargsCommandHelpers.js";
-const getDefaults = () => {
+const getDefaultOptions = () => {
   return {
     ...getYargsDefaults(),
     crud: {
@@ -34,15 +34,16 @@ const builder = (yargs) => {
       "https://cedarjs.com/docs/cli-commands#generate-sdl"
     )}`
   );
-  Object.entries(getDefaults()).forEach(([option, config]) => {
+  Object.entries(getDefaultOptions()).forEach(([option, config]) => {
     yargs.option(option, config);
   });
+  return yargs;
 };
 const handler = createHandler("sdl");
 export {
   builder,
   command,
   description,
-  getDefaults,
+  getDefaultOptions,
   handler
 };

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

@@ -49,8 +49,11 @@ const modelFieldToSDL = ({
   types = {},
   docs = false
 }) => {
-  if (Object.entries(types).length) {
-    field.type = field.kind === "object" ? idType(types[field.type]) : field.type;
+  if (Object.entries(types).length && field.kind === "object") {
+    const resolvedType = idType(types[field.type]);
+    if (typeof resolvedType === "string") {
+      field.type = resolvedType;
+    }
   }
   const prismaTypeToGraphqlType = {
     Json: "JSON",
@@ -74,33 +77,33 @@ const inputSDL = (model, required, types = {}, docs = false) => {
   const ignoredFields = DEFAULT_IGNORE_FIELDS_FOR_INPUT;
   return model.fields.filter((field) => {
     const idField = model.fields.find((field2) => field2.isId);
-    if (idField && idField.default) {
+    if (idField?.default) {
       ignoredFields.push(idField.name);
     }
-    return ignoredFields.indexOf(field.name) === -1 && field.kind !== "object";
+    return !ignoredFields.includes(field.name) && field.kind !== "object";
   }).map((field) => modelFieldToSDL({ field, required, types, docs }));
 };
-const idInputSDL = (idType2, docs) => {
+function idInputSDL(idType2, docs) {
   if (!Array.isArray(idType2)) {
     return [];
   }
   return idType2.map(
     (field) => modelFieldToSDL({ field, required: true, types: {}, docs })
   );
-};
+}
 const createInputSDL = (model, types = {}, docs = false) => {
   return inputSDL(model, true, types, 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) {
@@ -108,7 +111,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;
@@ -121,13 +124,28 @@ const idName = (model, crud) => {
   return idField.name;
 };
 const sdlFromSchemaModel = async (name, crud, docs = false) => {
-  const model = await getSchema(name);
-  const types = (await Promise.all(
+  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 resolvedTypes = await Promise.all(
     model.fields.filter((field) => field.kind === "object").map(async (field) => {
-      const model2 = await getSchema(field.type);
-      return model2;
+      const fieldModel = await getSchema(field.type);
+      return fieldModel && "fields" in fieldModel ? fieldModel : void 0;
     })
-  )).reduce((acc, cur) => ({ ...acc, [cur.name]: cur }), {});
+  );
+  const types = resolvedTypes.reduce(
+    (acc, cur) => {
+      if (!cur) {
+        return acc;
+      }
+      return { ...acc, [cur.name]: cur };
+    },
+    {}
+  );
   const enums = (await Promise.all(
     model.fields.filter((field) => field.kind === "enum").map(async (field) => {
       const enumDef = await getEnum(field.type);
@@ -237,9 +255,11 @@ const handler = async ({
     }
     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);
+    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 {

package/dist/commands/generate/secret/secret.js

@@ -3,27 +3,27 @@ import { terminalLink } from "termi-link";
 import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
 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
 };

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

@@ -5,12 +5,21 @@ import { transformTSToJS } from "../../../lib/index.js";
 import { getSchema, verifyModelName } from "../../../lib/schemaHelpers.js";
 import { 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] = {
@@ -27,11 +36,11 @@ const parseSchema = async (model) => {
 };
 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 +64,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 +136,18 @@ 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 modelName = camelcase(singularize(model));
-  let inputObj = {};
+  const inputObj = {};
   scalarFields.forEach((field) => {
     if (foreignKeys.includes(field.name)) {
       inputObj[field.name] = `scenario.${modelName}.two.${field.name}`;
@@ -152,7 +165,9 @@ const fieldsToUpdate = async (model) => {
   const { scalarFields, relations, foreignKeys } = await parseSchema(model);
   const modelName = camelcase(singularize(model));
   let field, newValue, fieldName;
-  field = scalarFields.find((scalar) => !foreignKeys.includes(scalar.name));
+  field = scalarFields.find(
+    (scalar) => !foreignKeys.includes(scalar.name)
+  );
   if (!field) {
     field = scalarFields[0];
   }
@@ -168,25 +183,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 +215,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 +229,17 @@ 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;
+  }
+  return schemaResult.fields.find((field) => field.isId)?.name;
 };
 const files = async ({
   name,
@@ -223,7 +252,15 @@ const files = async ({
   const model = name;
   const idName = await getIdName(model);
   const prismaImportSource = "src/lib/db";
-  const modelRelations = relations || relationsForModel(await getSchema(model));
+  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",

package/dist/commands/generate/yargsCommandHelpers.js

@@ -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

@@ -51,7 +51,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,
@@ -126,6 +130,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(
         [
           {
@@ -137,28 +145,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 * as generateCell from "./generate/cell/cell.js";
 import * as generateComponent from "./generate/component/component.js";
 import * as generateDataMigration from "./generate/dataMigration/dataMigration.js";
@@ -22,19 +22,12 @@ import * as generateService from "./generate/service/service.js";
 const command = "generate <type>";
 const aliases = ["g"];
 const description = "Generate boilerplate code and type definitions";
-const getExitCode = (error) => {
-  if (typeof error !== "object" || error === null) {
-    return void 0;
-  }
-  const exitCode = Reflect.get(error, "exitCode");
-  return typeof exitCode === "number" ? exitCode : void 0;
-};
 const builder = (yargs) => yargs.command("types", "Generate supplementary code", {}, () => {
   recordTelemetryAttributes({ command: "generate types" });
   try {
-    execa.sync("yarn", ["cedar-gen"], { stdio: "inherit" });
+    runBinSync("cedar-gen", [], { stdio: "inherit" });
   } catch (error) {
-    process.exitCode = getExitCode(error) ?? 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/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 ({
   _,
@@ -13,11 +14,11 @@ const handler = async ({
     args.push(name.length > 1 ? `--${name}` : `-${name}`);
     args.push(String(value));
   }
-  let command = `yarn cedar-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 cedar-log-formatter";
+    command += ` | ${formatRunBinCommand("cedar-log-formatter")}`;
     process.env.LOG_LEVEL = originalLogLevel || "debug";
   }
   execa.commandSync(command, {

package/dist/commands/prismaHandler.js

@@ -1,8 +1,11 @@
 import fs from "node:fs";
-import path from "node:path";
 import boxen from "boxen";
-import execa from "execa";
 import { recordTelemetryAttributes, colors as c } from "@cedarjs/cli-helpers";
+import {
+  formatCedarCommand,
+  formatRunBinCommand
+} from "@cedarjs/cli-helpers/packageManager/display";
+import { runTransitiveBinSync } from "@cedarjs/cli-helpers/packageManager/exec";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { getPaths } from "../lib/index.js";
 const getErrorMessage = (error) => {
@@ -57,14 +60,12 @@ const handler = async ({
   }
   console.log();
   console.log(c.note("Running Prisma CLI..."));
-  console.log(c.underline(`$ yarn prisma ${args.join(" ")}`));
+  console.log(c.underline(`$ <pm exec> prisma ${args.join(" ")}`));
   console.log();
   try {
-    const prismaBin = path.join(cedarPaths.base, "node_modules/.bin/prisma");
-    execa.sync(prismaBin, args, {
+    runTransitiveBinSync("prisma", args, {
       cwd: cedarPaths.base,
-      stdio: "inherit",
-      cleanup: true
+      stdio: "inherit"
     });
     if (hasHelpOption || args.length === 0) {
       printWrapInfo();
@@ -81,8 +82,8 @@ const printWrapInfo = () => {
   const message = [
     c.bold("Cedar CLI wraps Prisma CLI"),
     "",
-    "Use `yarn cedar prisma` to automatically pass `--config` and `--preview-feature` options.",
-    "Use `yarn prisma` to skip Cedar's automatic CLI options.",
+    `Use \`${formatCedarCommand(["prisma"])}\` to automatically pass \`--config\` and \`--preview-feature\` options.`,
+    `Use \`${formatRunBinCommand("prisma")}\` to skip Cedar's automatic CLI options.`,
     "",
     "Find more information in our docs:",
     c.underline("https://cedarjs.com/docs/cli-commands#prisma")