@cedarjs/cli 0.0.4

package/dist/commands/generate/sdl/templates/sdl.ts.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
+  }<% } %>
+`

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

@@ -0,0 +1,52 @@
+import crypto from "node:crypto";
+import terminalLink from "terminal-link";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+const DEFAULT_LENGTH = 32;
+const generateSecret = (length = DEFAULT_LENGTH) => {
+  return crypto.randomBytes(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(
+    "Redwood CLI Reference",
+    "https://redwoodjs.com/docs/cli-commands#generate-secret"
+  )}`
+);
+const handler = ({ length, raw }) => {
+  recordTelemetryAttributes({
+    command: "generate secret",
+    length,
+    raw
+  });
+  if (raw) {
+    console.log(generateSecret(length));
+    return;
+  }
+  console.info("");
+  console.info(`  ${generateSecret(length)}`);
+  console.info("");
+  console.info(
+    "If you're using this with dbAuth, set a SESSION_SECRET environment variable to this value."
+  );
+  console.info("");
+  console.info("Keep it secret, keep it safe!");
+};
+export {
+  DEFAULT_LENGTH,
+  builder,
+  command,
+  description,
+  generateSecret,
+  handler
+};

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

@@ -0,0 +1,50 @@
+import terminalLink from "terminal-link";
+import {
+  createCommand,
+  createDescription,
+  createHandler,
+  getYargsDefaults
+} from "../yargsCommandHelpers.js";
+const defaults = () => {
+  const defaults2 = {
+    ...getYargsDefaults(),
+    tests: {
+      description: "Generate test files",
+      type: "boolean"
+    },
+    crud: {
+      default: true,
+      description: "Create CRUD functions",
+      type: "boolean"
+    }
+  };
+  return defaults2;
+};
+const command = createCommand("service");
+const description = createDescription("service");
+const builder = (yargs) => {
+  yargs.positional("name", {
+    description: "Name of the service",
+    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-service"
+    )}`
+  );
+  Object.entries(defaults()).forEach(([option, config]) => {
+    yargs.option(option, config);
+  });
+};
+const handler = createHandler("service");
+export {
+  builder,
+  command,
+  defaults,
+  description,
+  handler
+};

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

@@ -0,0 +1,301 @@
+import camelcase from "camelcase";
+import { transformTSToJS } from "../../../lib/index.js";
+import { pluralize, singularize } from "../../../lib/rwPluralize.js";
+import { getSchema, verifyModelName } from "../../../lib/schemaHelpers.js";
+import { relationsForModel } from "../helpers.js";
+import {
+  createHandler,
+  templateForComponentFile
+} from "../yargsHandlerHelpers.js";
+const DEFAULT_SCENARIO_NAMES = ["one", "two"];
+const parseSchema = async (model) => {
+  const schema = await getSchema(model);
+  const relations = {};
+  let foreignKeys = [];
+  let scalarFields = schema.fields.filter((field) => {
+    if (field.relationFromFields) {
+      if (field.isRequired && field.relationFromFields.length !== 0) {
+        relations[field.name] = {
+          foreignKey: field.relationFromFields,
+          type: field.type
+        };
+      }
+      foreignKeys = foreignKeys.concat(field.relationFromFields);
+    }
+    return field.isRequired && !field.hasDefaultValue && // don't include fields that the database will default
+    !field.relationName;
+  });
+  return { scalarFields, relations, foreignKeys };
+};
+const scenarioFieldValue = (field) => {
+  const randFloat = Math.random() * 1e7;
+  const randInt = parseInt(Math.random() * 1e7);
+  const randIntArray = [
+    parseInt(Math.random() * 300),
+    parseInt(Math.random() * 300),
+    parseInt(Math.random() * 300)
+  ];
+  switch (field.type) {
+    case "BigInt":
+      return `${BigInt(randInt)}n`;
+    case "Boolean":
+      return true;
+    case "DateTime":
+      return /* @__PURE__ */ new Date();
+    case "Decimal":
+    case "Float":
+      return randFloat;
+    case "Int":
+      return randInt;
+    case "Json":
+      return { foo: "bar" };
+    case "String":
+      return field.isUnique ? `String${randInt}` : "String";
+    case "Bytes":
+      return `Buffer.from([${randIntArray}])`;
+    default: {
+      if (field.kind === "enum" && field.enumValues[0]) {
+        return field.enumValues[0].dbName || field.enumValues[0].name;
+      }
+    }
+  }
+};
+const fieldsToScenario = async (scalarFields, relations, foreignKeys) => {
+  const data = {};
+  scalarFields.forEach((field) => {
+    if (!foreignKeys.length || !foreignKeys.includes(field.name)) {
+      data[field.name] = scenarioFieldValue(field);
+    }
+  });
+  for (const [relationName, relData] of Object.entries(relations)) {
+    const relationModelName = relData.type;
+    const {
+      scalarFields: relScalarFields,
+      relations: relRelations,
+      foreignKeys: relForeignKeys
+    } = await parseSchema(relationModelName);
+    data[relationName] = {
+      create: await fieldsToScenario(
+        relScalarFields,
+        relRelations,
+        relForeignKeys
+      )
+    };
+  }
+  return data;
+};
+const buildScenario = async (model) => {
+  const scenarioModelName = camelcase(model);
+  const standardScenario = {
+    [scenarioModelName]: {}
+  };
+  const { scalarFields, relations, foreignKeys } = await parseSchema(model);
+  for (const name of DEFAULT_SCENARIO_NAMES) {
+    standardScenario[scenarioModelName][name] = {};
+    const scenarioData = await fieldsToScenario(
+      scalarFields,
+      relations,
+      foreignKeys
+    );
+    Object.keys(scenarioData).forEach((key) => {
+      const value = scenarioData[key];
+      if (value && typeof value === "string" && value.match(/^\d+n$/)) {
+        scenarioData[key] = `${value.slice(0, value.length - 1)}n`;
+      }
+    });
+    standardScenario[scenarioModelName][name].data = scenarioData;
+  }
+  return standardScenario;
+};
+const buildStringifiedScenario = async (model) => {
+  const scenario = await buildScenario(model);
+  const jsonString = JSON.stringify(scenario, (_key, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    if (typeof value === "string" && value.match(/^\d+n$/)) {
+      return Number(value.slice(0, value.length - 1));
+    }
+    return value;
+  });
+  return jsonString.replace(/"Buffer\.from\(([^)]+)\)"/g, "Buffer.from($1)");
+};
+const fieldTypes = async (model) => {
+  const { scalarFields } = await parseSchema(model);
+  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 = {};
+  scalarFields.forEach((field) => {
+    if (foreignKeys.includes(field.name)) {
+      inputObj[field.name] = `scenario.${modelName}.two.${field.name}`;
+    } else {
+      inputObj[field.name] = scenarioFieldValue(field);
+    }
+  });
+  if (Object.keys(inputObj).length > 0) {
+    return inputObj;
+  } else {
+    return false;
+  }
+};
+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));
+  if (!field) {
+    field = scalarFields[0];
+  }
+  if (!field) {
+    return false;
+  }
+  if (foreignKeys.includes(field.name)) {
+    fieldName = Object.values(relations)[0].foreignKey;
+    newValue = `scenario.${modelName}.two.${field.name}`;
+  } else {
+    fieldName = field.name;
+    const value = scenarioFieldValue(field);
+    newValue = value;
+    switch (field.type) {
+      case "BigInt":
+        newValue = `${newValue + 1n}`;
+        break;
+      case "Boolean": {
+        newValue = !value;
+        break;
+      }
+      case "DateTime": {
+        let date = /* @__PURE__ */ new Date();
+        date.setDate(date.getDate() + 1);
+        newValue = date;
+        break;
+      }
+      case "Decimal":
+      case "Float": {
+        newValue = newValue + 1.1;
+        break;
+      }
+      case "Int": {
+        newValue = newValue + 1;
+        break;
+      }
+      case "Json": {
+        newValue = { foo: "baz" };
+        break;
+      }
+      case "String": {
+        newValue = newValue + "2";
+        break;
+      }
+      default: {
+        if (field.kind === "enum" && field.enumValues[field.enumValues.length - 1]) {
+          const enumVal = field.enumValues[field.enumValues.length - 1];
+          newValue = enumVal.dbName || enumVal.name;
+        }
+        break;
+      }
+    }
+  }
+  return { [fieldName]: newValue };
+};
+const getIdName = async (model) => {
+  const schema = await getSchema(model);
+  return schema.fields.find((field) => field.isId)?.name;
+};
+const files = async ({
+  name,
+  tests,
+  relations,
+  typescript,
+  ...rest
+}) => {
+  const componentName = camelcase(pluralize(name));
+  const model = name;
+  const idName = await getIdName(model);
+  const extension = "ts";
+  const modelRelations = relations || relationsForModel(await getSchema(model));
+  const serviceFile = await templateForComponentFile({
+    name,
+    componentName,
+    extension: `.${extension}`,
+    apiPathSection: "services",
+    generator: "service",
+    templatePath: `service.${extension}.template`,
+    templateVars: { relations: modelRelations, idName, ...rest }
+  });
+  const testFile = await templateForComponentFile({
+    name,
+    componentName,
+    extension: `.test.${extension}`,
+    apiPathSection: "services",
+    generator: "service",
+    templatePath: `test.${extension}.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 templateForComponentFile({
+    name,
+    componentName,
+    extension: `.scenarios.${extension}`,
+    apiPathSection: "services",
+    generator: "service",
+    templatePath: `scenarios.${extension}.template`,
+    templateVars: {
+      scenario: await buildScenario(model),
+      stringifiedScenario: await buildStringifiedScenario(model),
+      prismaModel: model,
+      idName,
+      relations: modelRelations,
+      ...rest
+    }
+  });
+  const files2 = [serviceFile];
+  if (tests) {
+    files2.push(testFile);
+    files2.push(scenariosFile);
+  }
+  return files2.reduce(async (accP, [outputPath, content]) => {
+    const acc = await accP;
+    if (!typescript) {
+      content = await transformTSToJS(outputPath, content);
+      outputPath = outputPath.replace(".ts", ".js");
+    }
+    return {
+      [outputPath]: content,
+      ...acc
+    };
+  }, Promise.resolve({}));
+};
+const handler = createHandler({
+  componentName: "service",
+  preTasksFn: verifyModelName,
+  filesFn: files
+});
+export {
+  buildScenario,
+  buildStringifiedScenario,
+  fieldTypes,
+  fieldsToInput,
+  fieldsToScenario,
+  fieldsToUpdate,
+  files,
+  handler,
+  parseSchema,
+  scenarioFieldValue
+};

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

@@ -0,0 +1,7 @@
+import type { Prisma, ${prismaModel} } from '@prisma/client'
+
+import type { ScenarioData } from '@cedarjs/testing/api'
+
+export const standard = defineScenario<Prisma.${prismaModel}CreateArgs>(${stringifiedScenario})
+
+export type StandardScenario = ScenarioData<${prismaModel}, '${camelName}'>

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

@@ -0,0 +1,38 @@
+import type { QueryResolvers<% if (crud) { %>, MutationResolvers<% } %><% if (relations.length) { %>, ${singularPascalName}RelationResolvers<% } %> } from 'types/graphql'
+
+import { db } from 'src/lib/db'
+
+export const ${pluralCamelName}: QueryResolvers['${pluralCamelName}'] = () => {
+  return db.${singularCamelName}.findMany()
+}<% if (crud || relations.length) { %>
+
+export const ${singularCamelName}: QueryResolvers['${singularCamelName}'] = ({ ${idName} }) => {
+  return db.${singularCamelName}.findUnique({
+    where: { ${idName} },
+  })
+}<% } %><% if (crud) { %>
+
+export const create${singularPascalName}: MutationResolvers['create${singularPascalName}'] = ({ input }) => {
+  return db.${singularCamelName}.create({
+    data: input,
+  })
+}
+
+export const update${singularPascalName}: MutationResolvers['update${singularPascalName}'] = ({ ${idName}, input }) => {
+  return db.${singularCamelName}.update({
+    data: input,
+    where: { ${idName} },
+  })
+}
+
+export const delete${singularPascalName}: MutationResolvers['delete${singularPascalName}'] = ({ ${idName} }) => {
+  return db.${singularCamelName}.delete({
+    where: { ${idName} },
+  })
+}<% } %><% if (relations.length) { %>
+
+export const ${singularPascalName}: ${singularPascalName}RelationResolvers = {<% relations.forEach(relation => { %>
+  ${relation}: (_obj, { root }) => {
+    return db.${singularCamelName}.findUnique({ where: { ${idName}: root?.${idName} } }).${relation}()
+  },<% }) %>
+}<% } %>

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

@@ -0,0 +1,84 @@
+<% // Transforms an object or single value into something that's more suitable
+   // for generating test cases
+   // If a `type` is passed in, the string for creating an object of that type
+   // will be generated
+   // If no type, or a type we don't support, is passed in we'll default to
+   // generating regular strings
+   // Looks for quoted strings, either by single (') or double (") quotes.
+   // When found
+   // - Removes the quotes around `scenario` variables.
+   // - Removes the quotes around `BigInt` fields.
+  const transformValue = (obj, type) => {
+    if (type === 'DateTime') {
+      return `new Date('${obj.toISOString()}')`
+    } else if (type === 'Decimal') {
+      return `new Prisma.Decimal(${obj})`
+    }
+
+    const jsonString = JSON.stringify(obj).replace(/['"].*?['"]/g, (string) => {
+      if (string.match(/scenario\./)) {
+        return string.replace(/['"]/g, '')
+      }
+
+      // BigInt
+      if (string.match(/^\"\d+n\"$/)) {
+        return string.slice(1, string.length - 1)
+      }
+
+      return string
+    })
+
+    // Not all values can be represented as JSON, like function invocations
+    return jsonString.replace(/"Buffer\.from\(([^)]+)\)"/g, 'Buffer.from($1)')
+  } %>
+<% if (prismaImport) { %>import { Prisma, ${prismaModel} } from '@prisma/client'<% } else { %>import type { ${prismaModel} } from '@prisma/client'<% } %>
+
+import { ${pluralCamelName}<% if (crud) { %>,${singularCamelName}, create${singularPascalName}, update${singularPascalName}, delete${singularPascalName}<% } %> } from './${pluralCamelName}'
+import type { StandardScenario } from './${pluralCamelName}.scenarios'
+
+// Generated boilerplate tests do not account for all circumstances
+// and can fail without adjustments, e.g. Float.
+//           Please refer to the RedwoodJS Testing Docs:
+//       https://redwoodjs.com/docs/testing#testing-services
+// https://redwoodjs.com/docs/testing#jest-expect-type-considerations
+
+describe('${pluralCamelName}', () => {
+  scenario('returns all ${pluralCamelName}', async (scenario: StandardScenario) => {
+    const result = await ${pluralCamelName}()
+
+    expect(result.length).toEqual(Object.keys(scenario.${singularCamelName}).length)
+  })<% if (crud) { %>
+
+  scenario('returns a single ${singularCamelName}', async (scenario: StandardScenario) => {
+    const result = await ${singularCamelName}({ ${idName}: scenario.${singularCamelName}.one.${idName} })
+
+    expect(result).toEqual(scenario.${singularCamelName}.one)
+  })
+
+  <% if (create) { %>scenario('creates a ${singularCamelName}', async (${transformValue(create).includes('scenario.') ? 'scenario: StandardScenario' : ''}) => {
+    const result = await create${singularPascalName}({
+      input: ${transformValue(create)},
+    })
+
+    <% for (const [name, value] of Object.entries(create)) { %>
+    expect(result.${name}).toEqual(${transformValue(value, types[name])})<% } %>
+  })<% } %>
+
+  <% if (update) { %>scenario('updates a ${singularCamelName}', async (scenario: StandardScenario) => {<% rand = parseInt(Math.random() * 10000000) %>
+    const original = await (${singularCamelName}({ ${idName}: scenario.${singularCamelName}.one.${idName} })) as ${prismaModel}
+    const result = await update${singularPascalName}({
+      ${idName}: original.${idName},
+      input: ${transformValue(update)},
+    })
+
+    <% for (const [name, value] of Object.entries(update)) { %>
+    expect(result.${name}).toEqual(${transformValue(value, types[name])})<% } %>
+  })<% } %>
+
+  scenario('deletes a ${singularCamelName}', async (scenario: StandardScenario) => {
+    const original = (await delete${singularPascalName}({ ${idName}: scenario.${singularCamelName}.one.${idName} })) as ${prismaModel}
+    const result = await ${singularCamelName}({ ${idName}: original.${idName} })
+
+    expect(result).toEqual(null)
+  })<% } %>
+})

package/dist/commands/generate/yargsCommandHelpers.js

@@ -0,0 +1,77 @@
+import terminalLink from "terminal-link";
+import { isTypeScriptProject } from "@cedarjs/cli-helpers";
+const getYargsDefaults = () => ({
+  force: {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing files",
+    type: "boolean"
+  },
+  typescript: {
+    alias: "ts",
+    default: isTypeScriptProject(),
+    description: "Generate TypeScript files",
+    type: "boolean"
+  }
+});
+const appendPositionalsToCmd = (commandString, positionalsObj) => {
+  if (Object.keys(positionalsObj).length > 0) {
+    const positionalNames = Object.keys(positionalsObj).map((positionalName) => `[${positionalName}]`).join(" ");
+    return `${commandString} ${positionalNames}`;
+  } else {
+    return commandString;
+  }
+};
+function createCommand(componentName, positionalsObj = {}) {
+  return appendPositionalsToCmd(`${componentName} <name>`, positionalsObj);
+}
+function createDescription(componentName) {
+  return `Generate a ${componentName} component`;
+}
+function createBuilder({ componentName, optionsObj, positionalsObj }) {
+  return (yargs) => {
+    yargs.positional("name", {
+      description: `Name of the ${componentName}`,
+      type: "string"
+    }).epilogue(
+      `Also see the ${terminalLink(
+        "Redwood CLI Reference",
+        `https://redwoodjs.com/docs/cli-commands#generate-${componentName}`
+      )}`
+    ).option("tests", {
+      description: "Generate test files",
+      type: "boolean"
+    }).option("stories", {
+      description: "Generate storybook files",
+      type: "boolean"
+    }).option("verbose", {
+      description: "Print all logs",
+      type: "boolean",
+      default: false
+    }).option("rollback", {
+      description: "Revert all generator actions if an error occurs",
+      type: "boolean",
+      default: true
+    });
+    Object.entries(positionalsObj || {}).forEach(([option, config]) => {
+      yargs.positional(option, config);
+    });
+    const opts = typeof optionsObj === "object" ? optionsObj : typeof optionsObj === "function" ? optionsObj() : getYargsDefaults();
+    Object.entries(opts).forEach(([option, config]) => {
+      yargs.option(option, config);
+    });
+  };
+}
+function createHandler(componentName) {
+  return async function handler(argv) {
+    const { handler: importedHandler } = await import(`./${componentName}/${componentName}Handler.js`);
+    return importedHandler(argv);
+  };
+}
+export {
+  createBuilder,
+  createCommand,
+  createDescription,
+  createHandler,
+  getYargsDefaults
+};