@cedarjs/cli 0.0.4

package/dist/commands/generate/directive/templates/transformer.directive.ts.template

@@ -0,0 +1,38 @@
+import {
+  createTransformerDirective,
+  TransformerDirectiveFunc,
+} from '@cedarjs/graphql-server'
+import { logger } from 'src/lib/logger'
+
+export const schema = gql`
+  """
+  Use @${camelName} to transform the resolved value to return a modified result.
+  """
+  directive @${camelName} on FIELD_DEFINITION
+`
+
+const transform: TransformerDirectiveFunc = ({ context, resolvedValue }) => {
+  /**
+    * Write your transformation logic inside this function.
+    * Transformer directives run **after** resolving the value
+    *
+    * - You can also throw an error, if you want to stop executing, but note that the value has already been resolved
+    * - Transformer directives **must** be synchronous, and return a value
+  **/
+
+  // currentUser is only available when auth is setup.
+  logger.debug({ currentUser: context.currentUser }, 'currentUser in ${camelName} directive')
+
+  // ... you can modify the resolvedValue and return it
+  logger.debug(resolvedValue, 'resolvedValue in ${camelName} directive')
+
+  // You can also modify your directive to take arguments
+  // and use the directiveArgs object provided to this function to get values
+  // See documentation here: https://redwoodjs.com/docs/directives
+
+  return resolvedValue.replace('foo', 'bar')
+}
+
+const ${camelName} = createTransformerDirective(schema, transform)
+
+export default ${camelName}

package/dist/commands/generate/directive/templates/validator.directive.test.ts.template

@@ -0,0 +1,17 @@
+import { mockRedwoodDirective, getDirectiveName } from '@cedarjs/testing/api'
+
+import  ${camelName} from './${camelName}'
+
+describe('${camelName} directive', () => {
+  it('declares the directive sdl as schema, with the correct name', () => {
+    expect(${camelName}.schema).toBeTruthy()
+    expect(getDirectiveName(${camelName}.schema)).toBe('${camelName}')
+  })
+
+
+  it('has a ${camelName} throws an error if validation does not pass', () => {
+    const mockExecution = mockRedwoodDirective(${camelName}, {})
+
+    expect(mockExecution).toThrowError('Implementation missing for ${camelName}')
+  })
+})

package/dist/commands/generate/directive/templates/validator.directive.ts.template

@@ -0,0 +1,39 @@
+import {
+  createValidatorDirective,
+  ValidatorDirectiveFunc,
+} from '@cedarjs/graphql-server'
+
+import { logger } from 'src/lib/logger'
+
+export const schema = gql`
+  """
+  Use @${camelName} to validate access to a field, query or mutation.
+  """
+  directive @${camelName} on FIELD_DEFINITION
+`
+
+const validate: ValidatorDirectiveFunc = ({ context, directiveArgs }) => {
+  /**
+   * Write your validation logic inside this function.
+   * Validator directives do not have access to the field value, i.e. they are called before resolving the value
+   *
+   * - Throw an error, if you want to stop executing e.g. not sufficient permissions
+   * - Validator directives can be async or sync
+   * - Returned value will be ignored
+  */
+
+  // currentUser is only available when auth is setup.
+  logger.debug({ currentUser: context.currentUser }, 'currentUser in ${camelName} directive')
+
+  // You can also modify your directive to take arguments
+  // and use the directiveArgs object provided to this function to get values
+  // See documentation here: https://redwoodjs.com/docs/directives
+  logger.debug(directiveArgs, 'directiveArgs in ${camelName} directive')
+
+
+  throw new Error('Implementation missing for ${camelName}')
+}
+
+const ${camelName} = createValidatorDirective(schema, validate)
+
+export default ${camelName}

package/dist/commands/generate/function/function.js

@@ -0,0 +1,29 @@
+import terminalLink from "terminal-link";
+import { getYargsDefaults, createHandler } from "../yargsCommandHelpers.js";
+const command = "function <name>";
+const description = "Generate a Function";
+const builder = (yargs) => {
+  yargs.positional("name", {
+    description: "Name of the Function",
+    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-function"
+    )}`
+  );
+  Object.entries(getYargsDefaults()).forEach(([option, config]) => {
+    yargs.option(option, config);
+  });
+};
+const handler = createHandler("function");
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/generate/function/functionHandler.js

@@ -0,0 +1,131 @@
+import path from "path";
+import camelcase from "camelcase";
+import { Listr } from "listr2";
+import terminalLink from "terminal-link";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../../lib/colors.js";
+import {
+  getPaths,
+  transformTSToJS,
+  writeFilesTask
+} from "../../../lib/index.js";
+import { prepareForRollback } from "../../../lib/rollback.js";
+import { validateName } from "../helpers.js";
+import { templateForComponentFile } from "../yargsHandlerHelpers.js";
+const files = async ({
+  name,
+  typescript: generateTypescript = false,
+  tests: generateTests = true,
+  ...rest
+}) => {
+  const extension = generateTypescript ? ".ts" : ".js";
+  const functionName = camelcase(name);
+  const outputFiles = [];
+  const functionFiles = await templateForComponentFile({
+    name: functionName,
+    componentName: functionName,
+    extension,
+    apiPathSection: "functions",
+    generator: "function",
+    templatePath: "function.ts.template",
+    templateVars: { ...rest, typescript: generateTypescript },
+    outputPath: path.join(
+      getPaths().api.functions,
+      functionName,
+      `${functionName}${extension}`
+    )
+  });
+  outputFiles.push(functionFiles);
+  if (generateTests) {
+    const testFile = await templateForComponentFile({
+      name: functionName,
+      componentName: functionName,
+      extension,
+      apiPathSection: "functions",
+      generator: "function",
+      templatePath: "test.ts.template",
+      templateVars: { ...rest },
+      outputPath: path.join(
+        getPaths().api.functions,
+        functionName,
+        `${functionName}.test${extension}`
+      )
+    });
+    const scenarioFile = await templateForComponentFile({
+      name: functionName,
+      componentName: functionName,
+      extension,
+      apiPathSection: "functions",
+      generator: "function",
+      templatePath: "scenarios.ts.template",
+      templateVars: { ...rest },
+      outputPath: path.join(
+        getPaths().api.functions,
+        functionName,
+        `${functionName}.scenarios${extension}`
+      )
+    });
+    outputFiles.push(testFile);
+    outputFiles.push(scenarioFile);
+  }
+  return outputFiles.reduce(async (accP, [outputPath, content]) => {
+    const acc = await accP;
+    const template = generateTypescript ? content : await transformTSToJS(outputPath, content);
+    return {
+      [outputPath]: template,
+      ...acc
+    };
+  }, Promise.resolve({}));
+};
+const handler = async ({ name, force, ...rest }) => {
+  recordTelemetryAttributes({
+    command: "generate function",
+    force,
+    rollback: rest.rollback
+  });
+  validateName(name);
+  const tasks = new Listr(
+    [
+      {
+        title: "Generating function files...",
+        task: async () => {
+          return writeFilesTask(await files({ name, ...rest }), {
+            overwriteExisting: force
+          });
+        }
+      }
+    ],
+    { rendererOptions: { collapseSubtasks: false }, exitOnError: true }
+  );
+  try {
+    if (rest.rollback && !force) {
+      prepareForRollback(tasks);
+    }
+    await tasks.run();
+    console.info("");
+    console.info(c.warning("\u26A0 Important:"));
+    console.info("");
+    console.info(
+      c.bold(
+        "When deployed, a custom serverless function is an open API endpoint and is your responsibility to secure appropriately."
+      )
+    );
+    console.info("");
+    console.info(
+      `Please consult the ${terminalLink(
+        "Serverless Function Considerations",
+        "https://redwoodjs.com/docs/serverless-functions#security-considerations"
+      )} in the RedwoodJS documentation for more information.`
+    );
+    console.info("");
+  } 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/function/templates/function.ts.template

@@ -0,0 +1,33 @@
+import type { APIGatewayEvent, Context } from 'aws-lambda'
+
+import { logger } from 'src/lib/logger'
+
+/**
+ * The handler function is your code that processes http request events.
+ * You can use return and throw to send a response or error, respectively.
+ *
+ * Important: When deployed, a custom serverless function is an open API endpoint and
+ * is your responsibility to secure appropriately.
+ *
+ * @see {@link https://redwoodjs.com/docs/serverless-functions#security-considerations|Serverless Function Considerations}
+ * in the RedwoodJS documentation for more information.
+ *<% if (!typescript) { %>
+ * @typedef { import('aws-lambda').APIGatewayEvent } APIGatewayEvent
+ * @typedef { import('aws-lambda').Context } Context<% } %>
+ * @param { APIGatewayEvent } event - an object which contains information from the invoker.
+ * @param { Context } _context - contains information about the invocation,
+ * function, and execution environment.
+ */
+export const handler = async (event: APIGatewayEvent, _context: Context) => {
+  logger.info(`<%= '$' %>{event.httpMethod} <%= '$' %>{event.path}: <%= name %> function`)
+
+  return {
+    statusCode: 200,
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      data: '${name} function',
+    }),
+  }
+}

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

@@ -0,0 +1,8 @@
+import type { ScenarioData } from '@cedarjs/testing/api'
+
+export const standard = defineScenario({
+  // Define the "fixture" to write into your test database here
+  // See guide: https://redwoodjs.com/docs/testing#scenarios
+})
+
+export type StandardScenario = ScenarioData<unknown>

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

@@ -0,0 +1,30 @@
+import { mockHttpEvent, mockContext } from '@cedarjs/testing/api'
+
+import { handler } from './${name}'
+
+//   Improve this test with help from the Redwood Testing Doc:
+//    https://redwoodjs.com/docs/testing#testing-functions
+
+describe('${name} function', () => {
+
+  it('Should respond with 200', async () => {
+    const httpEvent = mockHttpEvent({
+      queryStringParameters: {
+        id: '42', // Add parameters here
+      },
+    })
+
+    const response = await handler(httpEvent, mockContext())
+    const { data } = JSON.parse(response.body)
+
+    expect(response.statusCode).toBe(200)
+    expect(data).toBe('${name} function')
+  })
+
+// You can also use scenarios to test your api functions
+// See guide here: https://redwoodjs.com/docs/testing#scenarios
+//
+// scenario('Scenario test', async () => {
+//
+// })
+})

package/dist/commands/generate/helpers.js

@@ -0,0 +1,71 @@
+import { paramCase } from "change-case";
+import pascalcase from "pascalcase";
+import { pluralize, isPlural, isSingular } from "../../lib/rwPluralize.js";
+const pathName = (path, name) => {
+  let routePath = path;
+  if (path && path.startsWith("{") && path.endsWith("}")) {
+    routePath = `/${paramCase(name)}/${path}`;
+  }
+  if (!routePath) {
+    routePath = `/${paramCase(name)}`;
+  }
+  return routePath;
+};
+function removeGeneratorName(name, generatorName) {
+  const pascalComponentName = pascalcase(generatorName);
+  const coercedName = name.replace(new RegExp(pascalComponentName + "$"), "");
+  return coercedName;
+}
+const validateName = (name) => {
+  if (name.match(/^\W/)) {
+    throw new Error(
+      "The <name> argument must start with a letter, number or underscore."
+    );
+  }
+};
+const relationsForModel = (model) => {
+  return model.fields.filter((f) => f.relationName).map((field) => {
+    return field.name;
+  });
+};
+const intForeignKeysForModel = (model) => {
+  return model.fields.filter((f) => f.name.match(/Id$/) && f.type === "Int").map((f) => f.name);
+};
+const forcePluralizeWord = (word) => {
+  if (isPlural(word) && isSingular(word)) {
+    return pascalcase(`${word}_list`);
+  }
+  return pluralize(word);
+};
+const mapRouteParamTypeToTsType = (paramType) => {
+  const routeParamToTsType = {
+    Int: "number",
+    Float: "number",
+    Boolean: "boolean",
+    String: "string"
+  };
+  return routeParamToTsType[paramType] || "unknown";
+};
+const mapPrismaScalarToPagePropTsType = (scalarType) => {
+  const prismaScalarToTsType = {
+    String: "string",
+    Boolean: "boolean",
+    Int: "number",
+    BigInt: "number",
+    Float: "number",
+    Decimal: "number",
+    DateTime: "string",
+    Bytes: "Buffer"
+  };
+  return prismaScalarToTsType[scalarType] || "unknown";
+};
+export {
+  forcePluralizeWord,
+  intForeignKeysForModel,
+  mapPrismaScalarToPagePropTsType,
+  mapRouteParamTypeToTsType,
+  pathName,
+  relationsForModel,
+  removeGeneratorName,
+  validateName
+};

package/dist/commands/generate/job/job.js

@@ -0,0 +1,39 @@
+import terminalLink from "terminal-link";
+import { isTypeScriptProject } from "../../../lib/project.js";
+import { getYargsDefaults, createHandler } from "../yargsCommandHelpers.js";
+const command = "job <name>";
+const description = "Generate a Background Job";
+const builder = (yargs) => {
+  yargs.positional("name", {
+    description: "Name of the Job",
+    type: "string"
+  }).option("typescript", {
+    alias: "ts",
+    description: "Generate TypeScript files",
+    type: "boolean",
+    default: isTypeScriptProject()
+  }).option("tests", {
+    description: "Generate test files",
+    type: "boolean",
+    default: true
+  }).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-job"
+    )}`
+  );
+  Object.entries(getYargsDefaults()).forEach(([option, config]) => {
+    yargs.option(option, config);
+  });
+};
+const handler = createHandler("job");
+export {
+  builder,
+  command,
+  description,
+  handler
+};

package/dist/commands/generate/job/jobHandler.js

@@ -0,0 +1,138 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import * as changeCase from "change-case";
+import execa from "execa";
+import { Listr } from "listr2";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { errorTelemetry } from "@cedarjs/telemetry";
+import c from "../../../lib/colors.js";
+import {
+  getPaths,
+  transformTSToJS,
+  writeFilesTask
+} from "../../../lib/index.js";
+import { prepareForRollback } from "../../../lib/rollback.js";
+import { validateName } from "../helpers.js";
+import { templateForComponentFile } from "../yargsHandlerHelpers.js";
+const normalizeName = (name) => {
+  return changeCase.pascalCase(name).replace(/Job$/, "");
+};
+const files = async ({
+  name,
+  queueName,
+  typescript: generateTypescript,
+  tests: generateTests = true,
+  ...rest
+}) => {
+  const extension = generateTypescript ? ".ts" : ".js";
+  const outputFiles = [];
+  const jobName = normalizeName(name);
+  const jobFiles = await templateForComponentFile({
+    name: jobName,
+    componentName: jobName,
+    extension,
+    apiPathSection: "jobs",
+    generator: "job",
+    templatePath: "job.ts.template",
+    templateVars: { name: jobName, queueName, ...rest },
+    outputPath: path.join(
+      getPaths().api.jobs,
+      `${jobName}Job`,
+      `${jobName}Job${extension}`
+    )
+  });
+  outputFiles.push(jobFiles);
+  if (generateTests) {
+    const testFile = await templateForComponentFile({
+      name: jobName,
+      componentName: jobName,
+      extension,
+      apiPathSection: "jobs",
+      generator: "job",
+      templatePath: "test.ts.template",
+      templateVars: { ...rest },
+      outputPath: path.join(
+        getPaths().api.jobs,
+        `${jobName}Job`,
+        `${jobName}Job.test${extension}`
+      )
+    });
+    const scenarioFile = await templateForComponentFile({
+      name: jobName,
+      componentName: jobName,
+      extension,
+      apiPathSection: "jobs",
+      generator: "job",
+      templatePath: "scenarios.ts.template",
+      templateVars: { ...rest },
+      outputPath: path.join(
+        getPaths().api.jobs,
+        `${jobName}Job`,
+        `${jobName}Job.scenarios${extension}`
+      )
+    });
+    outputFiles.push(testFile);
+    outputFiles.push(scenarioFile);
+  }
+  return outputFiles.reduce(async (accP, [outputPath, content]) => {
+    const acc = await accP;
+    const template = generateTypescript ? content : await transformTSToJS(outputPath, content);
+    return {
+      [outputPath]: template,
+      ...acc
+    };
+  }, Promise.resolve({}));
+};
+const handler = async ({ name, force, ...rest }) => {
+  recordTelemetryAttributes({
+    command: "generate job",
+    force,
+    rollback: rest.rollback
+  });
+  validateName(name);
+  let queueName = "default";
+  try {
+    const jobsManagerFile = getPaths().api.distJobsConfig;
+    const jobManager = await import(pathToFileURL(jobsManagerFile).href);
+    queueName = jobManager.jobs?.queues[0] ?? "default";
+  } catch (_e) {
+  }
+  const tasks = new Listr(
+    [
+      {
+        title: "Generating job files...",
+        task: async () => {
+          const jobFiles = await files({ name, queueName, ...rest });
+          return writeFilesTask(jobFiles, { overwriteExisting: force });
+        }
+      },
+      {
+        title: "Cleaning up...",
+        task: () => {
+          execa.commandSync("yarn", [
+            "eslint",
+            "--fix",
+            "--config",
+            `${getPaths().base}/node_modules/@cedarjs/eslint-config/shared.js`,
+            `${getPaths().api.jobsConfig}`
+          ]);
+        }
+      }
+    ],
+    { rendererOptions: { collapseSubtasks: false }, exitOnError: true }
+  );
+  try {
+    if (rest.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/job/templates/job.ts.template

@@ -0,0 +1,8 @@
+import { jobs } from 'src/lib/jobs'
+
+export const ${name}Job = jobs.createJob({
+  queue: '${queueName}',
+  perform: async () => {
+    jobs.logger.info('${name}Job is performing...')
+  }
+})

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

@@ -0,0 +1,8 @@
+import type { ScenarioData } from '@cedarjs/testing/api'
+
+export const standard = defineScenario({
+  // Define the "fixture" to write into your test database here
+  // See guide: https://redwoodjs.com/docs/testing#scenarios
+})
+
+export type StandardScenario = ScenarioData<unknown>

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

@@ -0,0 +1,7 @@
+import { ${name}Job } from './${name}Job'
+
+describe('${name}Job', () => {
+  it('should not throw any errors', async () => {
+    await expect(${name}Job.perform()).resolves.not.toThrow()
+  })
+})

package/dist/commands/generate/layout/layout.js

@@ -0,0 +1,25 @@
+import {
+  createCommand,
+  createDescription,
+  createBuilder,
+  createHandler,
+  getYargsDefaults
+} from "../yargsCommandHelpers.js";
+const optionsObj = () => ({
+  skipLink: {
+    default: false,
+    description: "Generate with skip link",
+    type: "boolean"
+  },
+  ...getYargsDefaults()
+});
+const command = createCommand("layout");
+const description = createDescription("layout");
+const builder = createBuilder({ componentName: "layout", optionsObj });
+const handler = createHandler("layout");
+export {
+  builder,
+  command,
+  description,
+  handler
+};