@cedarjs/cli 0.0.4

package/dist/lib/index.js

@@ -0,0 +1,485 @@
+import { execSync } from "child_process";
+import https from "https";
+import path from "path";
+import * as babel from "@babel/core";
+import boxen from "boxen";
+import camelcase from "camelcase";
+import { paramCase } from "change-case";
+import decamelize from "decamelize";
+import execa from "execa";
+import fs from "fs-extra";
+import { Listr } from "listr2";
+import lodash from "lodash";
+import pascalcase from "pascalcase";
+import { format } from "prettier";
+import {
+  getConfig as getRedwoodConfig,
+  getPaths as getRedwoodPaths,
+  resolveFile as internalResolveFile,
+  findUp
+} from "@cedarjs/project-config";
+import c from "./colors.js";
+import { addFileToRollback } from "./rollback.js";
+import { pluralize, singularize } from "./rwPluralize.js";
+const { memoize, template } = lodash;
+const nameVariants = (name) => {
+  const normalizedName = pascalcase(paramCase(singularize(name)));
+  return {
+    pascalName: pascalcase(paramCase(name)),
+    camelName: camelcase(name),
+    singularPascalName: normalizedName,
+    pluralPascalName: pluralize(normalizedName),
+    singularCamelName: camelcase(normalizedName),
+    pluralCamelName: camelcase(pluralize(normalizedName)),
+    singularParamName: paramCase(normalizedName),
+    pluralParamName: paramCase(pluralize(normalizedName)),
+    singularConstantName: decamelize(normalizedName).toUpperCase(),
+    pluralConstantName: decamelize(pluralize(normalizedName)).toUpperCase()
+  };
+};
+const generateTemplate = async (templateFilename, { name, ...rest }) => {
+  try {
+    const templateFn = template(readFile(templateFilename).toString());
+    const renderedTemplate = templateFn({
+      name,
+      ...nameVariants(name),
+      ...rest
+    });
+    return prettify(templateFilename, renderedTemplate);
+  } catch (error) {
+    error.message = `Error applying template at ${templateFilename} for ${name}: ${error.message}`;
+    throw error;
+  }
+};
+const prettify = async (templateFilename, renderedTemplate) => {
+  const parser = {
+    ".css": "css",
+    ".js": "babel",
+    ".jsx": "babel",
+    ".ts": "babel-ts",
+    ".tsx": "babel-ts"
+  }[path.extname(templateFilename.replace(".template", ""))];
+  if (typeof parser === "undefined") {
+    return renderedTemplate;
+  }
+  const prettierOptions = await getPrettierOptions();
+  return format(renderedTemplate, {
+    ...prettierOptions,
+    parser
+  });
+};
+const readFile = (target) => fs.readFileSync(target, { encoding: "utf8" });
+const SUPPORTED_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx"];
+const deleteFile = (file) => {
+  const extension = path.extname(file);
+  if (SUPPORTED_EXTENSIONS.includes(extension)) {
+    const baseFile = getBaseFile(file);
+    SUPPORTED_EXTENSIONS.forEach((ext) => {
+      const f = baseFile + ext;
+      if (fs.existsSync(f)) {
+        fs.unlinkSync(f);
+      }
+    });
+  } else {
+    fs.unlinkSync(file);
+  }
+};
+const getBaseFile = (file) => file.replace(/\.\w*$/, "");
+const existsAnyExtensionSync = (file) => {
+  const extension = path.extname(file);
+  if (SUPPORTED_EXTENSIONS.includes(extension)) {
+    const baseFile = getBaseFile(file);
+    return SUPPORTED_EXTENSIONS.some((ext) => fs.existsSync(baseFile + ext));
+  }
+  return fs.existsSync(file);
+};
+const writeFile = (target, contents, { overwriteExisting = false } = {}, task = {}) => {
+  const { base } = getPaths();
+  task.title = `Writing \`./${path.relative(base, target)}\``;
+  if (!overwriteExisting && fs.existsSync(target)) {
+    throw new Error(`${target} already exists.`);
+  }
+  addFileToRollback(target);
+  const filename = path.basename(target);
+  const targetDir = target.replace(filename, "");
+  fs.mkdirSync(targetDir, { recursive: true });
+  fs.writeFileSync(target, contents);
+  task.title = `Successfully wrote file \`./${path.relative(base, target)}\``;
+};
+const saveRemoteFileToDisk = (url, localPath, { overwriteExisting = false } = {}) => {
+  if (!overwriteExisting && fs.existsSync(localPath)) {
+    throw new Error(`${localPath} already exists.`);
+  }
+  const downloadPromise = new Promise(
+    (resolve, reject) => https.get(url, (response) => {
+      if (response.statusCode === 200) {
+        response.pipe(fs.createWriteStream(localPath));
+        resolve();
+      } else {
+        reject(
+          new Error(`${url} responded with status code ${response.statusCode}`)
+        );
+      }
+    })
+  );
+  return downloadPromise;
+};
+async function getInstalledCedarVersion() {
+  try {
+    const packageJson = await import("../../package.json", { with: { type: "json" } });
+    return packageJson.default.version;
+  } catch (e) {
+    console.error(c.error("Could not find installed Cedar version"));
+    process.exit(1);
+  }
+}
+const bytes = (contents) => Buffer.byteLength(contents, "utf8");
+const _getPaths = () => {
+  try {
+    return getRedwoodPaths();
+  } catch (e) {
+    console.error(c.error(e.message));
+    process.exit(1);
+  }
+};
+const getPaths = memoize(_getPaths);
+const resolveFile = internalResolveFile;
+const getGraphqlPath = () => resolveFile(path.join(getPaths().api.functions, "graphql"));
+const graphFunctionDoesExist = () => {
+  return fs.existsSync(getGraphqlPath());
+};
+const getConfig = () => {
+  try {
+    return getRedwoodConfig();
+  } catch (e) {
+    console.error(c.error(e.message));
+    process.exit(1);
+  }
+};
+const getPrettierOptions = async () => {
+  try {
+    const { default: prettierOptions } = await import(`file://${path.join(getPaths().base, "prettier.config.js")}`);
+    return prettierOptions;
+  } catch (e) {
+    if (process.env.VITEST_POOL_ID !== void 0) {
+      return {
+        trailingComma: "es5",
+        bracketSpacing: true,
+        tabWidth: 2,
+        semi: false,
+        singleQuote: true,
+        arrowParens: "always",
+        overrides: [
+          {
+            files: "Routes.*",
+            options: {
+              printWidth: 999
+            }
+          }
+        ]
+      };
+    }
+    return void 0;
+  }
+};
+const transformTSToJS = async (filename, content) => {
+  const { code } = babel.transform(content, {
+    filename,
+    // If you ran `yarn rw generate` in `./web` transformSync would import the `.babelrc.js` file,
+    // in `./web`? despite us setting `configFile: false`.
+    cwd: process.env.NODE_ENV === "test" ? void 0 : getPaths().base,
+    configFile: false,
+    plugins: [
+      [
+        "@babel/plugin-transform-typescript",
+        {
+          isTSX: true,
+          allExtensions: true
+        }
+      ]
+    ],
+    retainLines: true
+  });
+  return prettify(filename.replace(/\.ts(x)?$/, ".js$1"), code);
+};
+const writeFilesTask = (files, options) => {
+  const { base } = getPaths();
+  return new Listr(
+    Object.keys(files).map((file) => {
+      const contents = files[file];
+      return {
+        title: `...waiting to write file \`./${path.relative(base, file)}\`...`,
+        task: (ctx, task) => writeFile(file, contents, options, task)
+      };
+    })
+  );
+};
+const deleteFilesTask = (files) => {
+  const { base } = getPaths();
+  return new Listr([
+    ...Object.keys(files).map((file) => {
+      return {
+        title: `Destroying \`./${path.relative(base, getBaseFile(file))}\`...`,
+        skip: () => !existsAnyExtensionSync(file) && `File doesn't exist`,
+        task: () => deleteFile(file)
+      };
+    }),
+    {
+      title: "Cleaning up empty directories...",
+      task: () => cleanupEmptyDirsTask(files)
+    }
+  ]);
+};
+const cleanupEmptyDirsTask = (files) => {
+  const { base } = getPaths();
+  const endDirs = Object.keys(files).map((file) => path.dirname(file));
+  const uniqueEndDirs = [...new Set(endDirs)];
+  const pathDirs = [];
+  uniqueEndDirs.forEach((dir) => {
+    const relDir = path.relative(base, dir);
+    const splitDir = relDir.split(path.sep);
+    splitDir.pop();
+    while (splitDir.length > 3) {
+      const subDir = path.join(base, splitDir.join("/"));
+      pathDirs.push(subDir);
+      splitDir.pop();
+    }
+  });
+  const uniqueDirs = uniqueEndDirs.concat([...new Set(pathDirs)]);
+  return new Listr(
+    uniqueDirs.map((dir) => {
+      return {
+        title: `Removing empty \`./${path.relative(base, dir)}\`...`,
+        task: () => fs.rmdirSync(dir),
+        skip: () => {
+          if (!fs.existsSync(dir)) {
+            return `Doesn't exist`;
+          }
+          if (fs.readdirSync(dir).length > 0) {
+            return "Not empty";
+          }
+          return false;
+        }
+      };
+    })
+  );
+};
+const wrapWithSet = (routesContent, layout, routes, newLineAndIndent, props = {}) => {
+  const [_, indentOne, indentTwo] = routesContent.match(
+    /([ \t]*)<Router.*?>[^<]*[\r\n]+([ \t]+)/
+  ) || ["", 0, 2];
+  const oneLevelIndent = indentTwo.slice(0, indentTwo.length - indentOne.length);
+  const newRoutesWithExtraIndent = routes.map((route) => oneLevelIndent + route);
+  const propsString = Object.entries(props).map((values) => `${values[0]}="${values[1]}"`).join(" ");
+  return [
+    `<Set wrap={${layout}}${propsString && " " + propsString}>`,
+    ...newRoutesWithExtraIndent,
+    `</Set>`
+  ].join(newLineAndIndent);
+};
+const addRoutesToRouterTask = (routes, layout, setProps = {}) => {
+  const redwoodPaths = getPaths();
+  const routesContent = readFile(redwoodPaths.web.routes).toString();
+  let newRoutes = routes.filter((route) => !routesContent.match(route));
+  if (newRoutes.length) {
+    const [routerStart, routerParams, newLineAndIndent] = routesContent.match(
+      /\s*<Router(.*?)>(\s*)/s
+    );
+    if (/trailingSlashes={?(["'])always\1}?/.test(routerParams)) {
+      newRoutes = newRoutes.map((route) => {
+        if (route.length > 2e3) {
+          throw new Error(`Route is too long to process:
+${route}`);
+        }
+        return route.replace(/ path="(.+?)" /, ' path="$1/" ');
+      });
+    }
+    const routesBatch = layout ? wrapWithSet(
+      routesContent,
+      layout,
+      newRoutes,
+      newLineAndIndent,
+      setProps
+    ) : newRoutes.join(newLineAndIndent);
+    const newRoutesContent = routesContent.replace(
+      routerStart,
+      `${routerStart + routesBatch + newLineAndIndent}`
+    );
+    writeFile(redwoodPaths.web.routes, newRoutesContent, {
+      overwriteExisting: true
+    });
+  }
+};
+const addScaffoldImport = () => {
+  const appJsPath = getPaths().web.app;
+  let appJsContents = readFile(appJsPath).toString();
+  if (appJsContents.match("./scaffold.css")) {
+    return "Skipping scaffold style include";
+  }
+  appJsContents = appJsContents.replace(
+    /import ['"]\.\/index\.css['"]/,
+    "import './index.css'\nimport './scaffold.css'\n"
+  );
+  writeFile(appJsPath, appJsContents, { overwriteExisting: true });
+  return "Added scaffold import to App.{jsx,tsx}";
+};
+const removeEmtpySet = (routesContent, layout) => {
+  const setWithLayoutReg = new RegExp(
+    `\\s*<Set[^>]*wrap={${layout}}[^<]*>([^<]*)</Set>`
+  );
+  const [matchedSet, childContent] = routesContent.match(setWithLayoutReg) || [];
+  if (!matchedSet) {
+    return routesContent;
+  }
+  const child = childContent.replace(/\s/g, "");
+  if (child.length > 0) {
+    return routesContent;
+  }
+  return routesContent.replace(setWithLayoutReg, "");
+};
+const removeRoutesFromRouterTask = (routes, layout) => {
+  const redwoodPaths = getPaths();
+  const routesContent = readFile(redwoodPaths.web.routes).toString();
+  const newRoutesContent = routes.reduce((content, route) => {
+    const matchRouteByName = new RegExp(`\\s*<Route[^>]*name="${route}"[^>]*/>`);
+    return content.replace(matchRouteByName, "");
+  }, routesContent);
+  const routesWithoutEmptySet = layout ? removeEmtpySet(newRoutesContent, layout) : newRoutesContent;
+  writeFile(redwoodPaths.web.routes, routesWithoutEmptySet, {
+    overwriteExisting: true
+  });
+};
+const addPackagesTask = async ({
+  packages,
+  side = "project",
+  devDependency = false
+}) => {
+  const cedarVersion = await getInstalledCedarVersion();
+  const packagesWithSameRWVersion = packages.map((pkg) => {
+    if (pkg.includes("@cedarjs")) {
+      return `${pkg}@${cedarVersion}`;
+    } else {
+      return pkg;
+    }
+  });
+  let installCommand;
+  if (side !== "project") {
+    installCommand = [
+      "yarn",
+      [
+        "workspace",
+        side,
+        "add",
+        devDependency && "--dev",
+        ...packagesWithSameRWVersion
+      ].filter(Boolean)
+    ];
+  } else {
+    const stdout = execSync("yarn --version");
+    const yarnVersion = stdout.toString().trim();
+    installCommand = [
+      "yarn",
+      [
+        yarnVersion.startsWith("1") && "-W",
+        "add",
+        devDependency && "--dev",
+        ...packagesWithSameRWVersion
+      ].filter(Boolean)
+    ];
+  }
+  return {
+    title: `Adding dependencies to ${side}`,
+    task: async () => {
+      await execa(...installCommand);
+    }
+  };
+};
+const runCommandTask = async (commands, { verbose, silent }) => {
+  const tasks = new Listr(
+    commands.map(({ title, cmd, args, opts = {}, cwd = getPaths().base }) => ({
+      title,
+      task: async () => {
+        return execa(cmd, args, {
+          shell: true,
+          cwd,
+          stdio: verbose && !silent ? "inherit" : "pipe",
+          extendEnv: true,
+          cleanup: true,
+          ...opts
+        });
+      }
+    })),
+    {
+      renderer: silent ? "silent" : verbose ? "verbose" : "default",
+      rendererOptions: { collapseSubtasks: false, dateFormat: false }
+    }
+  );
+  try {
+    await tasks.run();
+    return true;
+  } catch (e) {
+    console.log(c.error(e.message));
+    return false;
+  }
+};
+const getDefaultArgs = (builder) => {
+  return Object.entries(builder).reduce(
+    (options, [optionName, optionConfig]) => {
+      options[optionName] = optionConfig.default;
+      return options;
+    },
+    {}
+  );
+};
+const usingVSCode = () => {
+  const redwoodPaths = getPaths();
+  const VS_CODE_PATH = path.join(redwoodPaths.base, ".vscode");
+  return fs.existsSync(VS_CODE_PATH);
+};
+const printSetupNotes = (notes) => {
+  return {
+    title: "One more thing...",
+    task: (_ctx, task) => {
+      task.title = `One more thing...
+
+ ${boxen(notes.join("\n"), {
+        padding: { top: 1, bottom: 1, right: 1, left: 1 },
+        margin: 1,
+        borderColour: "gray"
+      })}  
+`;
+    }
+  };
+};
+export {
+  _getPaths,
+  addPackagesTask,
+  addRoutesToRouterTask,
+  addScaffoldImport,
+  bytes,
+  cleanupEmptyDirsTask,
+  deleteFile,
+  deleteFilesTask,
+  existsAnyExtensionSync,
+  findUp,
+  generateTemplate,
+  getConfig,
+  getDefaultArgs,
+  getGraphqlPath,
+  getInstalledCedarVersion,
+  getPaths,
+  getPrettierOptions,
+  graphFunctionDoesExist,
+  nameVariants,
+  prettify,
+  printSetupNotes,
+  readFile,
+  removeRoutesFromRouterTask,
+  resolveFile,
+  runCommandTask,
+  saveRemoteFileToDisk,
+  transformTSToJS,
+  usingVSCode,
+  writeFile,
+  writeFilesTask
+};

package/dist/lib/loadEnvFiles.js

@@ -0,0 +1,12 @@
+import {
+  loadEnvFiles,
+  loadDefaultEnvFiles,
+  loadNodeEnvDerivedEnvFile,
+  loadUserSpecifiedEnvFiles
+} from "@cedarjs/cli-helpers";
+export {
+  loadDefaultEnvFiles,
+  loadEnvFiles,
+  loadNodeEnvDerivedEnvFile,
+  loadUserSpecifiedEnvFiles
+};

package/dist/lib/locking.js

@@ -0,0 +1,60 @@
+import path from "path";
+import fs from "fs-extra";
+import { getPaths } from "./index.js";
+function ensureLockDirectoryExists() {
+  const locksPath = path.join(getPaths().generated.base, "locks");
+  if (!fs.existsSync(locksPath)) {
+    fs.mkdirSync(locksPath, { recursive: true });
+  }
+}
+function setLock(identifier) {
+  ensureLockDirectoryExists();
+  if (isLockSet(identifier)) {
+    throw new Error(`Lock "${identifier}" is already set`);
+  }
+  fs.writeFileSync(
+    path.join(getPaths().generated.base, "locks", identifier),
+    ""
+  );
+}
+function unsetLock(identifier) {
+  try {
+    fs.rmSync(path.join(getPaths().generated.base, "locks", identifier));
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+function isLockSet(identifier) {
+  const lockfilePath = path.join(getPaths().generated.base, "locks", identifier);
+  const exists = fs.existsSync(lockfilePath);
+  if (!exists) {
+    return false;
+  }
+  const createdAt = fs.statSync(lockfilePath).birthtimeMs;
+  if (Date.now() - createdAt > 36e5) {
+    unsetLock(identifier);
+    return false;
+  }
+  return true;
+}
+function clearLocks(identifiers = []) {
+  ensureLockDirectoryExists();
+  if (identifiers.length > 0) {
+    for (const id of identifiers) {
+      unsetLock(id);
+    }
+  } else {
+    const locks = fs.readdirSync(path.join(getPaths().generated.base, "locks"));
+    for (const lock of locks) {
+      unsetLock(lock);
+    }
+  }
+}
+export {
+  clearLocks,
+  isLockSet,
+  setLock,
+  unsetLock
+};

package/dist/lib/merge/algorithms.js

@@ -0,0 +1,30 @@
+import { forOwn } from "lodash";
+const nodeIs = (type) => (node) => node.type === type;
+function sieve(...listRulePairs) {
+  const result = [[]];
+  for (const [list, rule] of listRulePairs) {
+    elementLoop: for (const element of list) {
+      for (const arr of result) {
+        const position = rule(arr);
+        if (position !== -1) {
+          arr.splice(position, 0, element);
+          continue elementLoop;
+        }
+      }
+      result.push([element]);
+    }
+  }
+  return result;
+}
+function forEachFunctionOn(object, callback) {
+  forOwn(object, (value, key) => {
+    if (typeof value === "function") {
+      callback(key, value);
+    }
+  });
+}
+export {
+  forEachFunctionOn,
+  nodeIs,
+  sieve
+};