@cedarjs/cli 0.0.4

package/dist/commands/generate/scaffold/templates/lib/formatters.tsx.template

@@ -0,0 +1,58 @@
+import React from 'react'
+
+import humanize from 'humanize-string'
+
+const MAX_STRING_LENGTH = 150
+
+export const formatEnum = (values: string | string[] | null | undefined) => {
+  let output = ''
+
+  if (Array.isArray(values)) {
+    const humanizedValues = values.map((value) => humanize(value))
+    output = humanizedValues.join(', ')
+  } else if (typeof values === 'string') {
+    output = humanize(values)
+  }
+
+  return output
+}
+
+export const jsonDisplay = (obj: unknown) => {
+  return (
+    <pre>
+      <code>{JSON.stringify(obj, null, 2)}</code>
+    </pre>
+  )
+}
+
+export const truncate = (value: string | number) => {
+  let output = value?.toString() ?? ''
+
+  if (output.length > MAX_STRING_LENGTH) {
+    output = output.substring(0, MAX_STRING_LENGTH) + '...'
+  }
+
+  return output
+}
+
+export const jsonTruncate = (obj: unknown) => {
+  return truncate(JSON.stringify(obj, null, 2))
+}
+
+export const timeTag = (dateTime?: string) => {
+  let output: string | JSX.Element = ''
+
+  if (dateTime) {
+    output = (
+      <time dateTime={dateTime} title={dateTime}>
+        {new Date(dateTime).toUTCString()}
+      </time>
+    )
+  }
+
+  return output
+}
+
+export const checkboxInputTag = (checked: boolean) => {
+  return <input type="checkbox" checked={checked} disabled />
+}

package/dist/commands/generate/scaffold/templates/pages/EditNamePage.tsx.template

@@ -0,0 +1,11 @@
+import Edit${singularPascalName}Cell from '${importComponentEditNameCell}'
+
+type ${pascalName}PageProps = {
+  ${idName}: ${idTsType}
+}
+
+const Edit${singularPascalName}Page = ({ ${idName} }: ${pascalName}PageProps) => {
+  return <Edit${singularPascalName}Cell ${idName}={${idName}} />
+}
+
+export default Edit${singularPascalName}Page

package/dist/commands/generate/scaffold/templates/pages/NamePage.tsx.template

@@ -0,0 +1,11 @@
+import ${singularPascalName}Cell from '${importComponentNameCell}'
+
+type ${pascalName}PageProps = {
+  ${idName}: ${idTsType}
+}
+
+const ${singularPascalName}Page = ({ ${idName} }: ${pascalName}PageProps) => {
+  return <${singularPascalName}Cell ${idName}={${idName}} />
+}
+
+export default ${singularPascalName}Page

package/dist/commands/generate/scaffold/templates/pages/NamesPage.tsx.template

@@ -0,0 +1,7 @@
+import ${pluralPascalName}Cell from '${importComponentNamesCell}'
+
+const ${pluralPascalName}Page = () => {
+  return <${pluralPascalName}Cell />
+}
+
+export default ${pluralPascalName}Page

package/dist/commands/generate/scaffold/templates/pages/NewNamePage.tsx.template

@@ -0,0 +1,7 @@
+import New${singularPascalName} from '${importComponentNewName}'
+
+const New${singularPascalName}Page = () => {
+  return <New${singularPascalName} />
+}
+
+export default New${singularPascalName}Page

package/dist/commands/generate/script/script.js

@@ -0,0 +1,29 @@
+import terminalLink from "terminal-link";
+import { createHandler, getYargsDefaults } from "../yargsCommandHelpers.js";
+const command = "script <name>";
+const description = "Generate a command line script";
+const builder = (yargs) => {
+  yargs.positional("name", {
+    description: "A descriptor of what this script does",
+    type: "string"
+  }).option("rollback", {
+    description: "Revert all generator actions if an error occurs",
+    type: "boolean",
+    default: true
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#generate-script"
+    )}`
+  );
+  Object.entries(getYargsDefaults()).forEach(([option, config]) => {
+    yargs.option(option, config);
+  });
+};
+const handler = createHandler("script");
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/generate/script/scriptHandler.js

@@ -0,0 +1,85 @@
+import path from "path";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../../lib/colors.js";
+import {
+  getPaths,
+  writeFilesTask,
+  transformTSToJS
+} from "../../../lib/index.js";
+import { prepareForRollback } from "../../../lib/rollback.js";
+import { validateName } from "../helpers.js";
+const TEMPLATE_PATH = path.resolve(
+  import.meta.dirname,
+  "templates",
+  "script.ts.template"
+);
+const TSCONFIG_TEMPLATE = path.resolve(
+  import.meta.dirname,
+  "templates",
+  "tsconfig.json.template"
+);
+const files = async ({ name, typescript = false }) => {
+  const outputFilename = `${name}.${typescript ? "ts" : "js"}`;
+  const outputPath = path.join(getPaths().scripts, outputFilename);
+  const scriptTsConfigPath = path.join(getPaths().scripts, "tsconfig.json");
+  const template = fs.readFileSync(TEMPLATE_PATH, "utf-8");
+  return {
+    [outputPath]: typescript ? template : await transformTSToJS(outputPath, template),
+    // Add tsconfig for type and cmd+click support if project is TS
+    ...typescript && !fs.existsSync(scriptTsConfigPath) && {
+      [scriptTsConfigPath]: fs.readFileSync(TSCONFIG_TEMPLATE, "utf-8")
+    }
+  };
+};
+const handler = async ({ force, ...args }) => {
+  recordTelemetryAttributes({
+    command: "generate script",
+    force,
+    rollback: args.rollback
+  });
+  const POST_RUN_INSTRUCTIONS = `Next steps...
+
+   ${c.warning(
+    "After modifying your script, you can invoke it like:"
+  )}
+
+     yarn rw exec ${args.name}
+
+     yarn rw exec ${args.name} --param1 true
+`;
+  validateName(args.name);
+  const tasks = new Listr(
+    [
+      {
+        title: "Generating script file...",
+        task: async () => {
+          return writeFilesTask(await files(args), { overwriteExisting: force });
+        }
+      },
+      {
+        title: "Next steps...",
+        task: (_ctx, task) => {
+          task.title = POST_RUN_INSTRUCTIONS;
+        }
+      }
+    ].filter(Boolean),
+    { rendererOptions: { collapseSubtasks: false } }
+  );
+  try {
+    if (args.rollback && !force) {
+      prepareForRollback(tasks);
+    }
+    await tasks.run();
+  } catch (e) {
+    errorTelemetry(process.argv, e.message);
+    console.log(c.error(e.message));
+    process.exit(1);
+  }
+};
+export {
+  files,
+  handler
+};

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

@@ -0,0 +1,15 @@
+// Append api/* to import from api and web/* to import from web
+
+// To access your database uncomment the line below
+// import { db } from 'api/src/lib/db'
+
+interface Args {
+  _: string[]
+  [key: string]: unknown
+}
+
+export default async ({ args }: Args) => {
+  // Your script here...
+  console.log(':: Executing script with args ::')
+  console.log(args)
+}

package/dist/commands/generate/script/templates/tsconfig.json.template

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true,
+    "esModuleInterop": true,
+    "baseUrl": "./",
+    "paths": {
+      "$api/*": [
+        "../api/*",
+      ],
+      "api/*": [
+        "../api/*",
+      ],
+      "$web/*": [
+        "../web/*",
+      ],
+      "web/*": [
+        "../web/*",
+      ],
+      "$web/src/*": [
+        "../web/src/*",
+        "../.redwood/types/mirror/web/src/*"
+      ],
+      "web/src/*": [
+        "../web/src/*",
+        "../.redwood/types/mirror/web/src/*"
+      ],
+      "types/*": ["../types/*", "../web/types/*", "../api/types/*"],
+    },
+    "typeRoots": ["../node_modules/@types"],
+    "jsx": "preserve",
+  },
+}

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

@@ -0,0 +1,48 @@
+import terminalLink from "terminal-link";
+import { createHandler, getYargsDefaults } from "../yargsCommandHelpers.js";
+const getDefaults = () => {
+  return {
+    ...getYargsDefaults(),
+    crud: {
+      default: true,
+      description: "Also generate mutations",
+      type: "boolean"
+    }
+  };
+};
+const command = "sdl <model>";
+const description = "Generate a GraphQL schema and service component based on a given DB schema Model";
+const builder = (yargs) => {
+  yargs.positional("model", {
+    description: "Model to generate the sdl for",
+    type: "string"
+  }).option("tests", {
+    description: "Generate test files",
+    type: "boolean"
+    // don't give it a default value, it gets overwritten in first few lines
+    // of the handler
+  }).option("docs", {
+    description: "Generate SDL and GraphQL comments to use in documentation",
+    type: "boolean"
+  }).option("rollback", {
+    description: "Revert all generator actions if an error occurs",
+    type: "boolean",
+    default: true
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "Redwood CLI Reference",
+      "https://redwoodjs.com/docs/cli-commands#generate-sdl"
+    )}`
+  );
+  Object.entries(getDefaults()).forEach(([option, config]) => {
+    yargs.option(option, config);
+  });
+};
+const handler = createHandler("sdl");
+export {
+  builder,
+  command,
+  description,
+  getDefaults,
+  handler
+};

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

@@ -0,0 +1,282 @@
+import path from "path";
+import boxen from "boxen";
+import camelcase from "camelcase";
+import chalk from "chalk";
+import { Listr } from "listr2";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { generate as generateTypes } from "@cedarjs/internal/dist/generate/generate";
+import { getConfig } from "@cedarjs/project-config";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../../lib/colors.js";
+import {
+  generateTemplate,
+  transformTSToJS,
+  getPaths,
+  writeFilesTask
+} from "../../../lib/index.js";
+import {
+  prepareForRollback,
+  addFunctionToRollback
+} from "../../../lib/rollback.js";
+import { pluralize } from "../../../lib/rwPluralize.js";
+import {
+  getSchema,
+  getEnum,
+  verifyModelName
+} from "../../../lib/schemaHelpers.js";
+import { relationsForModel } from "../helpers.js";
+import { files as serviceFiles } from "../service/serviceHandler.js";
+import { customOrDefaultTemplatePath } from "../yargsHandlerHelpers.js";
+const DEFAULT_IGNORE_FIELDS_FOR_INPUT = ["createdAt", "updatedAt"];
+const missingIdConsoleMessage = () => {
+  const line1 = chalk.bold.yellow("WARNING") + ": Cannot generate CRUD SDL without an `@id` database column.";
+  const line2 = "If you are trying to generate for a many-to-many join table ";
+  const line3 = "you'll need to update your schema definition to include";
+  const line4 = "an `@id` column. Read more here: ";
+  const line5 = chalk.underline.blue(
+    "https://redwoodjs.com/docs/schema-relations"
+  );
+  console.error(
+    boxen(line1 + "\n\n" + line2 + "\n" + line3 + "\n" + line4 + "\n" + line5, {
+      padding: 1,
+      margin: { top: 1, bottom: 3, right: 1, left: 2 },
+      borderStyle: "single"
+    })
+  );
+};
+const addFieldGraphQLComment = (field, str) => {
+  const description = field.documentation || `Description for ${field.name}.`;
+  return `
+  "${description}"
+  ${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",
+    Bytes: "Byte"
+  };
+  const gqlType = prismaTypeToGraphqlType[field.type] || field.type;
+  const type = field.isList ? `[${gqlType}]` : gqlType;
+  const isRequired = field.isRequired && required || field.isList || field.isId;
+  const fieldContent = `${field.name}: ${type}${isRequired ? "!" : ""}`;
+  if (docs) {
+    return addFieldGraphQLComment(field, fieldContent);
+  } else {
+    return fieldContent;
+  }
+};
+const querySDL = (model, docs = false) => {
+  return model.fields.map((field) => modelFieldToSDL({ field, docs }));
+};
+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) {
+      ignoredFields.push(idField.name);
+    }
+    return ignoredFields.indexOf(field.name) === -1 && field.kind !== "object";
+  }).map((field) => modelFieldToSDL({ field, required, types, docs }));
+};
+const 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) {
+    return void 0;
+  }
+  if (model.primaryKey?.fields.length) {
+    const { fields: fieldNames } = model.primaryKey;
+    return fieldNames.map((name) => model.fields.find((f) => f.name === name));
+  }
+  const idField = model.fields.find((field) => field.isId);
+  if (!idField) {
+    missingIdConsoleMessage();
+    throw new Error("Failed: Could not generate SDL");
+  }
+  return idField.type;
+};
+const idName = (model, crud) => {
+  if (!crud) {
+    return void 0;
+  }
+  const idField = model.fields.find((field) => field.isId);
+  if (!idField) {
+    missingIdConsoleMessage();
+    throw new Error("Failed: Could not generate SDL");
+  }
+  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 enums = (await Promise.all(
+    model.fields.filter((field) => field.kind === "enum").map(async (field) => {
+      const enumDef = await getEnum(field.type);
+      return enumDef;
+    })
+  )).reduce((acc, curr) => acc.concat(curr), []);
+  const modelName = model.name;
+  const modelDescription = model.documentation || `Representation of ${modelName}.`;
+  const idTypeRes = idType(model, crud);
+  return {
+    modelName,
+    modelDescription,
+    query: querySDL(model, docs).join("\n    "),
+    createInput: createInputSDL(model, types, docs).join("\n    "),
+    updateInput: updateInputSDL(model, types, docs).join("\n    "),
+    idInput: idInputSDL(idTypeRes, docs).join("\n    "),
+    idType: idType(model, crud),
+    idName: idName(model, crud),
+    relations: relationsForModel(model),
+    enums
+  };
+};
+const files = async ({
+  name,
+  crud = true,
+  docs = false,
+  tests,
+  typescript
+}) => {
+  const {
+    modelName,
+    modelDescription,
+    query,
+    createInput,
+    updateInput,
+    idInput,
+    idType: idType2,
+    idName: idName2,
+    relations,
+    enums
+  } = await sdlFromSchemaModel(name, crud, docs);
+  const templatePath = customOrDefaultTemplatePath({
+    side: "api",
+    generator: "sdl",
+    templatePath: "sdl.ts.template"
+  });
+  let template = await generateTemplate(templatePath, {
+    docs,
+    modelName,
+    modelDescription,
+    name,
+    crud,
+    query,
+    createInput,
+    updateInput,
+    idInput,
+    idType: idType2,
+    idName: idName2,
+    enums
+  });
+  const extension = typescript ? "ts" : "js";
+  let outputPath = path.join(
+    getPaths().api.graphql,
+    `${camelcase(pluralize(name))}.sdl.${extension}`
+  );
+  if (typescript) {
+    template = await transformTSToJS(outputPath, template);
+  }
+  return {
+    [outputPath]: template,
+    ...await serviceFiles({
+      name,
+      crud,
+      tests,
+      relations,
+      typescript
+    })
+  };
+};
+const handler = async ({
+  model,
+  crud,
+  force,
+  tests,
+  typescript,
+  docs,
+  rollback
+}) => {
+  if (tests === void 0) {
+    tests = getConfig().generate.tests;
+  }
+  recordTelemetryAttributes({
+    command: "generate sdl",
+    crud,
+    force,
+    tests,
+    typescript,
+    docs,
+    rollback
+  });
+  try {
+    const { name } = await verifyModelName({ name: model });
+    const tasks = new Listr(
+      [
+        {
+          title: "Generating SDL files...",
+          task: async () => {
+            const f = await files({ name, tests, crud, typescript, docs });
+            return writeFilesTask(f, { overwriteExisting: force });
+          }
+        },
+        {
+          title: `Generating types ...`,
+          task: async () => {
+            const { errors } = await generateTypes();
+            for (const { message, error } of errors) {
+              console.error(message);
+              console.log();
+              console.error(error);
+              console.log();
+            }
+            addFunctionToRollback(generateTypes, true);
+          }
+        }
+      ].filter(Boolean),
+      {
+        rendererOptions: { collapseSubtasks: false },
+        exitOnError: true,
+        silentRendererCondition: process.env.NODE_ENV === "test"
+      }
+    );
+    if (rollback && !force) {
+      prepareForRollback(tasks);
+    }
+    await tasks.run();
+  } catch (e) {
+    errorTelemetry(process.argv, e.message);
+    console.error(c.error(e.message));
+    process.exit(e?.exitCode || 1);
+  }
+};
+export {
+  files,
+  handler
+};

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

@@ -0,0 +1,70 @@
+export const schema = gql`
+  <% if (docs) { %>
+  """${modelDescription}"""
+  <% } %>
+  type ${singularPascalName} {
+    ${query}
+  }
+
+<% if (enums.length > 0) {%>
+<% enums.forEach((enumDef, idx)=> {
+  const enumName = enums[idx].name
+  const enumDescription = enums[idx].documentation || `Possible values for ${enums[idx].name}`
+  %>
+  <% if (docs) { %>
+  """${enumDescription}"""
+  <% } %>
+  enum ${enums[idx].name} {<% enums[idx].values.forEach((enumDefValue, idk)=> { %>
+    ${enums[idx].values[idk].name}<% }) %>
+  }
+<%}) %><% } %>
+  <% if (docs) { %>
+  """About queries"""
+  <% } %>
+  type Query {
+    <% if (docs) { %>
+    "Fetch ${pluralPascalName}."
+    <% } %>${pluralCamelName}: [${singularPascalName}!]! @requireAuth<% if (crud) { %>
+    <% if (docs) { %>
+    "Fetch a ${singularPascalName} by id."
+    <% } %>${singularCamelName}(${idName}: ${idType}!): ${singularPascalName} @requireAuth<% } %>
+  }
+
+  <% if (docs) { %>
+  """Autogenerated input type of Input${singularPascalName}."""
+  <% } %>
+  input Create${singularPascalName}Input {
+    ${createInput}
+  }
+
+  <% if (idInput) { %>
+    <% if (docs) { %>
+      """Autogenerated ID input type of ${singularPascalName}Id."""
+    <% } %>
+    input ${singularPascalName}IdInput {
+      ${idInput}
+    }
+  <% } %>
+
+  <% if (docs) { %>
+  """Autogenerated input type of Update${singularPascalName}."""
+  <% } %>
+  input Update${singularPascalName}Input {
+    ${updateInput}
+  }<% if (crud) { %>
+
+  <% if (docs) { %>
+  """About mutations"""
+  <% } %>
+  type Mutation {
+    <% if (docs) { %>
+    "Creates a new ${singularPascalName}."
+    <% } %>create${singularPascalName}(input: Create${singularPascalName}Input!): ${singularPascalName}! @requireAuth
+    <% if (docs) { %>
+    "Updates an existing ${singularPascalName}."
+    <% } %>update${singularPascalName}(${idName}: ${idType}!, input: Update${singularPascalName}Input!): ${singularPascalName}! @requireAuth
+    <% if (docs) { %>
+    "Deletes an existing ${singularPascalName}."
+    <% } %>delete${singularPascalName}(${idName}: ${idType}!): ${singularPascalName}! @requireAuth
+  }<% } %>
+`