@cedarjs/cli 0.0.4

package/dist/lib/colors.js

@@ -0,0 +1,18 @@
+import chalk from "chalk";
+var colors_default = {
+  error: chalk.bold.red,
+  warning: chalk.hex("#ffa500"),
+  highlight: chalk.hex("#ffa500"),
+  success: chalk.green,
+  info: chalk.grey,
+  bold: chalk.bold,
+  underline: chalk.underline,
+  note: chalk.blue,
+  tip: chalk.green,
+  important: chalk.magenta,
+  caution: chalk.red,
+  link: chalk.underline
+};
+export {
+  colors_default as default
+};

package/dist/lib/configureStorybook.js

@@ -0,0 +1,50 @@
+import path from "path";
+import fse from "fs-extra";
+import prettier from "prettier";
+import { merge } from "./merge/index.js";
+import {
+  interleave,
+  concatUnique,
+  keepBoth,
+  keepBothStatementParents
+} from "./merge/strategy.js";
+import { isTypeScriptProject } from "./project.js";
+import { getPaths, transformTSToJS, writeFile } from "./index.js";
+async function extendStorybookConfiguration(newConfigPath = void 0) {
+  const webPaths = getPaths().web;
+  const ts = isTypeScriptProject();
+  const sbPreviewConfigPath = webPaths.storybookPreviewConfig ?? `${webPaths.storybook}/preview.${ts ? "tsx" : "js"}`;
+  const read = (path2) => fse.readFileSync(path2, { encoding: "utf-8" });
+  if (!fse.existsSync(sbPreviewConfigPath)) {
+    const templateContent = read(
+      path.resolve(
+        import.meta.dirname,
+        "templates",
+        "storybook.preview.tsx.template"
+      )
+    );
+    const storybookPreviewContent2 = ts ? templateContent : await transformTSToJS(sbPreviewConfigPath, templateContent);
+    writeFile(sbPreviewConfigPath, storybookPreviewContent2);
+  }
+  const storybookPreviewContent = read(sbPreviewConfigPath);
+  if (newConfigPath) {
+    const newConfigTemplate = read(newConfigPath);
+    const newConfigContent = ts ? newConfigTemplate : await transformTSToJS(newConfigPath, newConfigTemplate);
+    const merged = await merge(storybookPreviewContent, newConfigContent, {
+      ImportDeclaration: interleave,
+      ArrayExpression: concatUnique,
+      ObjectExpression: concatUnique,
+      ArrowFunctionExpression: keepBothStatementParents,
+      FunctionDeclaration: keepBoth
+    });
+    const pConfig = await prettier.resolveConfig(sbPreviewConfigPath);
+    const formatted = await prettier.format(merged, {
+      parser: ts ? "babel-ts" : "babel",
+      ...pConfig
+    });
+    writeFile(sbPreviewConfigPath, formatted, { overwriteExisting: true });
+  }
+}
+export {
+  extendStorybookConfiguration as default
+};

package/dist/lib/exec.js

@@ -0,0 +1,85 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import {
+  getWebSideDefaultBabelConfig,
+  registerApiSideBabelHook
+} from "@cedarjs/babel-config";
+import { getPaths } from "@cedarjs/project-config";
+async function runScriptFunction({
+  path: scriptPath,
+  functionName,
+  args
+}) {
+  const createdRequire = createRequire(import.meta.url);
+  const script = createdRequire(scriptPath);
+  const returnValue = await script[functionName](args);
+  try {
+    const { db } = createdRequire(path.join(getPaths().api.lib, "db"));
+    db.$disconnect();
+  } catch (e) {
+  }
+  return returnValue;
+}
+async function configureBabel() {
+  const {
+    overrides: _overrides,
+    plugins: webPlugins,
+    ...otherWebConfig
+  } = getWebSideDefaultBabelConfig();
+  registerApiSideBabelHook({
+    plugins: [
+      [
+        "babel-plugin-module-resolver",
+        {
+          alias: {
+            $api: getPaths().api.base,
+            $web: getPaths().web.base,
+            api: getPaths().api.base,
+            web: getPaths().web.base
+          },
+          loglevel: "silent"
+          // to silence the unnecessary warnings
+        },
+        "exec-$side-module-resolver"
+      ]
+    ],
+    overrides: [
+      {
+        test: ["./api/"],
+        plugins: [
+          [
+            "babel-plugin-module-resolver",
+            {
+              alias: {
+                src: getPaths().api.src
+              },
+              loglevel: "silent"
+            },
+            "exec-api-src-module-resolver"
+          ]
+        ]
+      },
+      {
+        test: ["./web/"],
+        plugins: [
+          ...webPlugins,
+          [
+            "babel-plugin-module-resolver",
+            {
+              alias: {
+                src: getPaths().web.src
+              },
+              loglevel: "silent"
+            },
+            "exec-web-src-module-resolver"
+          ]
+        ],
+        ...otherWebConfig
+      }
+    ]
+  });
+}
+export {
+  configureBabel,
+  runScriptFunction
+};

package/dist/lib/exit.js

@@ -0,0 +1,44 @@
+import chalk from "chalk";
+import terminalLink from "terminal-link";
+import { v4 as uuidv4 } from "uuid";
+import {
+  recordTelemetryAttributes,
+  recordTelemetryError
+} from "@cedarjs/cli-helpers";
+const DEFAULT_ERROR_EPILOGUE = [
+  "Need help?",
+  ` - Not sure about something or need advice? Reach out on our ${terminalLink(
+    "Forum",
+    "https://community.redwoodjs.com/"
+  )}`,
+  ` - Think you've found a bug? Open an issue on our ${terminalLink(
+    "GitHub",
+    "https://github.com/cedarjs/cedar"
+  )}`
+].join("\n");
+function exitWithError(error, { exitCode, message, epilogue, includeEpilogue, includeReferenceCode } = {}) {
+  exitCode ??= error?.exitCode ?? 1;
+  epilogue ??= DEFAULT_ERROR_EPILOGUE;
+  includeEpilogue ??= true;
+  includeReferenceCode ??= true;
+  message ??= error.stack ?? (error.toString() || "Unknown error");
+  const errorReferenceCode = uuidv4();
+  const line = chalk.red("-".repeat(process.stderr.columns));
+  const content = !includeEpilogue ? message : [
+    "",
+    line,
+    message,
+    `
+${line}`,
+    epilogue,
+    includeReferenceCode && ` - Here's your unique error reference to quote: '${errorReferenceCode}'`,
+    line
+  ].filter(Boolean).join("\n");
+  console.error(content);
+  recordTelemetryError(error ?? new Error(message));
+  recordTelemetryAttributes({ errorReferenceCode });
+  process.exit(exitCode);
+}
+export {
+  exitWithError
+};

package/dist/lib/extendFile.js

@@ -0,0 +1,114 @@
+import fs from "fs-extra";
+function fileIncludes(path, str) {
+  return fs.existsSync(path) && fs.readFileSync(path).toString().includes(str);
+}
+function extendJSXFile(path, {
+  insertComponent: {
+    name = void 0,
+    props = void 0,
+    around = void 0,
+    within = void 0,
+    insertBefore = void 0,
+    insertAfter = void 0
+  },
+  imports = [],
+  moduleScopeLines = []
+}) {
+  const content = fs.readFileSync(path).toString().split("\n");
+  if (moduleScopeLines?.length) {
+    content.splice(
+      content.findLastIndex((l) => l.trimStart().startsWith("import")) + 1,
+      0,
+      "",
+      ...moduleScopeLines
+    );
+  }
+  if (imports?.length) {
+    content.splice(
+      content.findLastIndex((l) => l.includes("@cedarjs")) + 1,
+      0,
+      "",
+      ...imports
+    );
+  }
+  if (name) {
+    insertComponent(content, {
+      component: name,
+      props,
+      around,
+      within,
+      insertBefore,
+      insertAfter
+    });
+  }
+  fs.writeFileSync(path, content.filter((e) => e !== void 0).join("\n"));
+}
+function insertComponent(content, { component, props, around, within, insertBefore, insertAfter }) {
+  if (around && within || !(around || within)) {
+    throw new Error(
+      "Exactly one of (around | within) must be defined. Choose one."
+    );
+  }
+  const target = around ?? within;
+  const findTagIndex = (regex) => content.findIndex((line) => regex.test(line));
+  let open = findTagIndex(new RegExp(`([^\\S\r
+]*)<${target}\\s*(.*)\\s*>`));
+  let close = findTagIndex(new RegExp(`([^\\S\r
+]*)</${target}>`)) + 1;
+  if (open === -1 || close === -1) {
+    throw new Error(`Could not find tags for ${target}`);
+  }
+  if (within) {
+    open++;
+    close--;
+  }
+  const [, componentDepth] = content[open].match(/([^\S\r\n]*).*/);
+  content.splice(
+    open,
+    close - open,
+    // "Delete" the wrapped component contents. We put it back below.
+    insertBefore && componentDepth + insertBefore,
+    componentDepth + buildOpeningTag(component, props),
+    ...content.slice(open, close).map((line) => "  " + line),
+    componentDepth + `</${component}>`,
+    insertAfter && componentDepth + insertAfter
+  );
+}
+function buildOpeningTag(componentName, props) {
+  const propsString = (() => {
+    switch (typeof props) {
+      case "undefined":
+        return "";
+      case "object":
+        return objectToComponentProps(props, { raw: true }).join(" ");
+      case "string":
+        return props;
+      default:
+        throw new Error(
+          `Illegal argument passed for 'props'. Required: {Object | string | undefined}, got ${typeof props}`
+        );
+    }
+  })();
+  const possibleSpace = propsString.length ? " " : "";
+  return `<${componentName}${possibleSpace}${propsString}>`;
+}
+function objectToComponentProps(obj, options = { exclude: [], raw: false }) {
+  const props = [];
+  const doRaw = (key) => options.raw === true || Array.isArray(options.raw) && options.raw.includes(key);
+  for (const [key, value] of Object.entries(obj)) {
+    if (options.exclude && options.exclude.includes(key)) {
+      continue;
+    }
+    if (doRaw(key)) {
+      props.push(`${key}={${value}}`);
+    } else {
+      props.push(`${key}="${value}"`);
+    }
+  }
+  return props;
+}
+export {
+  extendJSXFile,
+  fileIncludes,
+  objectToComponentProps
+};

package/dist/lib/generatePrismaClient.js

@@ -0,0 +1,60 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import fs from "fs-extra";
+import { runCommandTask, getPaths } from "../lib/index.js";
+const skipTask = (schema = getPaths().api.dbSchema) => {
+  if (!fs.existsSync(schema)) {
+    console.log(
+      `Skipping database and Prisma client generation, no \`schema.prisma\` file found: \`${schema}\``
+    );
+    return true;
+  }
+  return false;
+};
+const generatePrismaCommand = (schema) => {
+  if (skipTask(schema)) {
+    return {};
+  }
+  const createdRequire = createRequire(import.meta.url);
+  const prismaIndexPath = createdRequire.resolve("prisma/build/index.js");
+  return {
+    cmd: `node "${prismaIndexPath}"`,
+    args: ["generate", schema && `--schema="${schema}"`]
+  };
+};
+const generatePrismaClient = async ({
+  verbose = true,
+  force = true,
+  silent = false,
+  schema = getPaths().api.dbSchema
+}) => {
+  if (skipTask(schema)) {
+    return;
+  }
+  if (!force) {
+    const prismaClientPath = path.join(
+      getPaths().base,
+      "node_modules/.prisma/client/index.js"
+    );
+    const prismaClientFile = fs.readFileSync(prismaClientPath, "utf8");
+    if (!prismaClientFile.includes("@prisma/client did not initialize yet.") && prismaClientFile.includes("exports.Prisma.")) {
+      return;
+    }
+  }
+  await runCommandTask(
+    [
+      {
+        title: "Generating the Prisma client...",
+        ...generatePrismaCommand(schema)
+      }
+    ],
+    {
+      verbose,
+      silent
+    }
+  );
+};
+export {
+  generatePrismaClient,
+  generatePrismaCommand
+};