@cedarjs/cli-helpers 0.0.4

package/dist/lib/index.js

@@ -0,0 +1,102 @@
+import fs from "fs";
+import path from "path";
+import * as babel from "@babel/core";
+import { Listr } from "listr2";
+import { format } from "prettier";
+import { colors } from "./colors.js";
+import { getPaths } from "./paths.js";
+const transformTSToJS = (filename, content) => {
+  if (!content) {
+    return content;
+  }
+  const babelFileResult = 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
+  });
+  if (!babelFileResult?.code) {
+    console.error(colors.error(`Could not transform ${filename} to JS`));
+    process.exit(1);
+  }
+  return prettify(filename.replace(/\.ts(x)?$/, ".js$1"), babelFileResult.code);
+};
+const getPrettierOptions = async () => {
+  try {
+    const { default: options } = await import(`file://${path.join(getPaths().base, "prettier.config.js")}`);
+    if (options.tailwindConfig?.startsWith(".")) {
+      options.tailwindConfig = path.join(
+        process.env.RWJS_CWD ?? process.cwd(),
+        options.tailwindConfig
+      );
+    }
+    return options;
+  } catch {
+    return void 0;
+  }
+};
+const prettify = async (templateFilename, renderedTemplate) => {
+  const parser = {
+    ".css": "css",
+    ".js": "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 writeFile = (target, contents, { existingFiles = "FAIL" } = {}, task = {}) => {
+  const { base } = getPaths();
+  task.title = `Writing \`./${path.relative(base, target)}\``;
+  const exists = fs.existsSync(target);
+  if (exists && existingFiles === "FAIL") {
+    throw new Error(`${target} already exists.`);
+  }
+  if (exists && existingFiles === "SKIP") {
+    task.skip(`Skipping update of \`./${path.relative(base, target)}\``);
+    return;
+  }
+  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 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) => {
+          return writeFile(file, contents, options, task);
+        }
+      };
+    })
+  );
+};
+export {
+  getPrettierOptions,
+  prettify,
+  transformTSToJS,
+  writeFile,
+  writeFilesTask
+};

package/dist/lib/installHelpers.d.ts

@@ -0,0 +1,17 @@
+export declare const addWebPackages: (webPackages: string[]) => {
+    title: string;
+    task: () => Promise<void>;
+};
+export declare const addApiPackages: (apiPackages: string[]) => {
+    title: string;
+    task: () => Promise<void>;
+};
+export declare const addRootPackages: (packages: string[], devDependency?: boolean) => {
+    title: string;
+    task: () => Promise<void>;
+};
+export declare const installPackages: {
+    title: string;
+    task: () => Promise<void>;
+};
+//# sourceMappingURL=installHelpers.d.ts.map

package/dist/lib/installHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installHelpers.d.ts","sourceRoot":"","sources":["../../src/lib/installHelpers.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,gBAAiB,MAAM,EAAE;;;CAKlD,CAAA;AAEF,eAAO,MAAM,cAAc,gBAAiB,MAAM,EAAE;;;CAKlD,CAAA;AAEF,eAAO,MAAM,eAAe,aAAc,MAAM,EAAE;;;CAQjD,CAAA;AAED,eAAO,MAAM,eAAe;;;CAK3B,CAAA"}

package/dist/lib/installHelpers.js

@@ -0,0 +1,35 @@
+import execa from "execa";
+import { getPaths } from "./paths.js";
+const addWebPackages = (webPackages) => ({
+  title: "Adding required web packages...",
+  task: async () => {
+    await execa("yarn", ["add", ...webPackages], { cwd: getPaths().web.base });
+  }
+});
+const addApiPackages = (apiPackages) => ({
+  title: "Adding required api packages...",
+  task: async () => {
+    await execa("yarn", ["add", ...apiPackages], { cwd: getPaths().api.base });
+  }
+});
+const addRootPackages = (packages, devDependency = false) => {
+  const addMode = devDependency ? ["add", "-D"] : ["add"];
+  return {
+    title: "Installing packages...",
+    task: async () => {
+      await execa("yarn", [...addMode, ...packages], { cwd: getPaths().base });
+    }
+  };
+};
+const installPackages = {
+  title: "Installing packages...",
+  task: async () => {
+    await execa("yarn", ["install"], { cwd: getPaths().base });
+  }
+};
+export {
+  addApiPackages,
+  addRootPackages,
+  addWebPackages,
+  installPackages
+};

package/dist/lib/loadEnvFiles.d.ts

@@ -0,0 +1,5 @@
+export declare function loadEnvFiles(): void;
+export declare function loadDefaultEnvFiles(cwd: string): void;
+export declare function loadNodeEnvDerivedEnvFile(cwd: string): void;
+export declare function loadUserSpecifiedEnvFiles(cwd: string, loadEnvFiles: string[]): void;
+//# sourceMappingURL=loadEnvFiles.d.ts.map

package/dist/lib/loadEnvFiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadEnvFiles.d.ts","sourceRoot":"","sources":["../../src/lib/loadEnvFiles.ts"],"names":[],"mappings":"AAUA,wBAAgB,YAAY,SAsB3B;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,QAQ9C;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,QAcpD;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,QAW5E"}

package/dist/lib/loadEnvFiles.js

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import path from "node:path";
+import { config as dotenvConfig } from "dotenv";
+import { config as dotenvDefaultsConfig } from "dotenv-defaults";
+import { hideBin } from "yargs/helpers";
+import parser from "yargs-parser";
+import { getPaths } from "@cedarjs/project-config";
+function loadEnvFiles() {
+  if (process.env.REDWOOD_ENV_FILES_LOADED) {
+    return;
+  }
+  const { base } = getPaths();
+  loadDefaultEnvFiles(base);
+  loadNodeEnvDerivedEnvFile(base);
+  const { loadEnvFiles: loadEnvFiles2 } = parser(hideBin(process.argv), {
+    array: ["load-env-files"],
+    default: {
+      loadEnvFiles: []
+    }
+  });
+  if (loadEnvFiles2.length > 0) {
+    loadUserSpecifiedEnvFiles(base, loadEnvFiles2);
+  }
+  process.env.REDWOOD_ENV_FILES_LOADED = "true";
+}
+function loadDefaultEnvFiles(cwd) {
+  dotenvDefaultsConfig({
+    path: path.join(cwd, ".env"),
+    defaults: path.join(cwd, ".env.defaults"),
+    // @ts-expect-error - Old typings. @types/dotenv-defaults depends on dotenv
+    // v8. dotenv-defaults uses dotenv v14
+    multiline: true
+  });
+}
+function loadNodeEnvDerivedEnvFile(cwd) {
+  if (!process.env.NODE_ENV) {
+    return;
+  }
+  const nodeEnvDerivedEnvFilePath = path.join(
+    cwd,
+    `.env.${process.env.NODE_ENV}`
+  );
+  if (!fs.existsSync(nodeEnvDerivedEnvFilePath)) {
+    return;
+  }
+  dotenvConfig({ path: nodeEnvDerivedEnvFilePath, override: true });
+}
+function loadUserSpecifiedEnvFiles(cwd, loadEnvFiles2) {
+  for (const suffix of loadEnvFiles2) {
+    const envPath = path.join(cwd, `.env.${suffix}`);
+    if (!fs.existsSync(envPath)) {
+      throw new Error(
+        `Couldn't find an .env file at '${envPath}' as specified by '--load-env-files'`
+      );
+    }
+    dotenvConfig({ path: envPath, override: true });
+  }
+}
+export {
+  loadDefaultEnvFiles,
+  loadEnvFiles,
+  loadNodeEnvDerivedEnvFile,
+  loadUserSpecifiedEnvFiles
+};

package/dist/lib/paths.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This wraps the core version of getPaths into something that catches the exception
+ * and displays a helpful error message.
+ */
+export declare function getPaths(): import("@cedarjs/project-config").Paths;
+//# sourceMappingURL=paths.d.ts.map

package/dist/lib/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/lib/paths.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,wBAAgB,QAAQ,4CAUvB"}

package/dist/lib/paths.js

@@ -0,0 +1,18 @@
+import { getPaths as _getPaths } from "@cedarjs/project-config";
+import { colors } from "./colors.js";
+function isErrorWithMessage(e) {
+  return !!e.message;
+}
+function getPaths() {
+  try {
+    return _getPaths();
+  } catch (e) {
+    if (isErrorWithMessage(e)) {
+      console.error(colors.error(e.message));
+    }
+    process.exit(1);
+  }
+}
+export {
+  getPaths
+};

package/dist/lib/project.d.ts

@@ -0,0 +1,42 @@
+import type { Config } from '@cedarjs/project-config';
+export declare const getGraphqlPath: () => string | null;
+export declare const graphFunctionDoesExist: () => boolean | "" | null;
+export declare const isTypeScriptProject: () => boolean;
+export declare const getInstalledRedwoodVersion: () => any;
+/**
+ * Updates the project's redwood.toml file to include the specified packages plugin
+ *
+ * Uses toml parsing to determine if the plugin is already included in the file and
+ * only adds it if it is not.
+ *
+ * Writes the updated config to the file system by appending strings, not stringify-ing the toml.
+ */
+export declare const updateTomlConfig: (packageName: string) => void;
+export declare const updateTomlConfigTask: (packageName: string) => {
+    title: string;
+    task: () => void;
+};
+export declare const addEnvVarTask: (name: string, value: string, comment: string) => {
+    title: string;
+    task: () => void;
+};
+export declare const addEnvVar: (name: string, value: string, comment: string) => string | void;
+/**
+ * This sets the `RWJS_CWD` env var to the redwood project directory. This is typically required for internal
+ * redwood packages to work correctly. For example, `@cedarjs/project-config` uses this when reading config
+ * or paths.
+ *
+ * @param cwd Explicitly set the redwood cwd. If not set, we'll try to determine it automatically. You likely
+ * only want to set this based on some specific input, like a CLI flag.
+ */
+export declare const setRedwoodCWD: (cwd?: string) => void;
+/**
+ * Create or update the given setting, in the given section, with the given value.
+ *
+ * If the section already exists it adds the new setting last
+ * If the section, and the setting, already exists, the setting is updated
+ * If the section does not exist it is created at the end of the file and the setting is added
+ * If the setting exists in the section, but is commented out, it will be uncommented and updated
+ */
+export declare function setTomlSetting(section: keyof Config, setting: string, value: string | boolean | number): void;
+//# sourceMappingURL=project.d.ts.map

package/dist/lib/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/lib/project.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAWrD,eAAO,MAAM,cAAc,qBAE1B,CAAA;AAED,eAAO,MAAM,sBAAsB,2BAGlC,CAAA;AAED,eAAO,MAAM,mBAAmB,eAM/B,CAAA;AAED,eAAO,MAAM,0BAA0B,WAQtC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,gBAAiB,MAAM,SAmDnD,CAAA;AAED,eAAO,MAAM,oBAAoB,gBAAiB,MAAM;;;CAOvD,CAAA;AAED,eAAO,MAAM,aAAa,SAAU,MAAM,SAAS,MAAM,WAAW,MAAM;;;CAOzE,CAAA;AAED,eAAO,MAAM,SAAS,SAAU,MAAM,SAAS,MAAM,WAAW,MAAM,kBAqCrE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,SAAU,MAAM,SAyBzC,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,QA0HjC"}

package/dist/lib/project.js

@@ -0,0 +1,227 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import dotenv from "dotenv";
+import * as toml from "smol-toml";
+import {
+  findUp,
+  getConfigPath,
+  getConfig,
+  resolveFile
+} from "@cedarjs/project-config";
+import { colors } from "./colors.js";
+import { getPaths } from "./paths.js";
+const getGraphqlPath = () => {
+  return resolveFile(path.join(getPaths().api.functions, "graphql"));
+};
+const graphFunctionDoesExist = () => {
+  const graphqlPath = getGraphqlPath();
+  return graphqlPath && fs.existsSync(graphqlPath);
+};
+const isTypeScriptProject = () => {
+  const paths = getPaths();
+  return fs.existsSync(path.join(paths.web.base, "tsconfig.json")) || fs.existsSync(path.join(paths.api.base, "tsconfig.json"));
+};
+const getInstalledRedwoodVersion = () => {
+  try {
+    const packageJson = require("../../package.json");
+    return packageJson.version;
+  } catch {
+    console.error(colors.error("Could not find installed Cedar version"));
+    process.exit(1);
+  }
+};
+const updateTomlConfig = (packageName) => {
+  const redwoodTomlPath = getConfigPath();
+  const originalTomlContent = fs.readFileSync(redwoodTomlPath, "utf-8");
+  let tomlToAppend = {};
+  const config = getConfig(redwoodTomlPath);
+  const cliSection = config.experimental?.cli;
+  if (!cliSection) {
+    tomlToAppend = {
+      experimental: {
+        cli: {
+          autoInstall: true,
+          plugins: [{ package: packageName, enabled: true }]
+        }
+      }
+    };
+  } else if (cliSection.plugins) {
+    const packageExists = cliSection.plugins.some(
+      (plugin) => plugin.package === packageName
+    );
+    if (!packageExists) {
+      tomlToAppend = {
+        experimental: {
+          cli: {
+            plugins: [{ package: packageName, enabled: true }]
+          }
+        }
+      };
+    }
+  } else {
+    tomlToAppend = {
+      experimental: {
+        cli: {
+          plugins: [{ package: packageName, enabled: true }]
+        }
+      }
+    };
+  }
+  const newConfig = originalTomlContent + "\n" + (Object.keys(tomlToAppend).length > 0 ? toml.stringify(tomlToAppend) + "\n" : "");
+  return fs.writeFileSync(redwoodTomlPath, newConfig, "utf-8");
+};
+const updateTomlConfigTask = (packageName) => {
+  return {
+    title: `Updating redwood.toml to configure ${packageName} ...`,
+    task: () => {
+      updateTomlConfig(packageName);
+    }
+  };
+};
+const addEnvVarTask = (name, value, comment) => {
+  return {
+    title: `Adding ${name} var to .env...`,
+    task: () => {
+      addEnvVar(name, value, comment);
+    }
+  };
+};
+const addEnvVar = (name, value, comment) => {
+  const envPath = path.join(getPaths().base, ".env");
+  let envFile = "";
+  const newEnvironmentVariable = [
+    comment && `# ${comment}`,
+    `${name}=${value}`,
+    ""
+  ].flat().join("\n");
+  if (fs.existsSync(envPath)) {
+    envFile = fs.readFileSync(envPath).toString();
+    const existingEnvVars = dotenv.parse(envFile);
+    if (existingEnvVars[name] && existingEnvVars[name] === value) {
+      return envFile;
+    }
+    if (existingEnvVars[name]) {
+      const p = [
+        `# Note: The existing environment variable ${name} was not overwritten. Uncomment to use its new value.`,
+        comment && `# ${comment}`,
+        `# ${name}=${value}`,
+        ""
+      ].flat().join("\n");
+      envFile += "\n" + p;
+    } else {
+      envFile += "\n" + newEnvironmentVariable;
+    }
+  } else {
+    envFile = newEnvironmentVariable;
+  }
+  return fs.writeFileSync(envPath, envFile);
+};
+const setRedwoodCWD = (cwd) => {
+  cwd ??= process.env.RWJS_CWD;
+  if (cwd) {
+    if (!fs.existsSync(path.join(cwd, "redwood.toml"))) {
+      throw new Error(`Couldn't find a "redwood.toml" file in ${cwd}`);
+    }
+  } else {
+    const redwoodTOMLPath = findUp("redwood.toml", process.cwd());
+    if (!redwoodTOMLPath) {
+      throw new Error(
+        `Couldn't find up a "redwood.toml" file from ${process.cwd()}`
+      );
+    }
+    if (redwoodTOMLPath) {
+      cwd = path.dirname(redwoodTOMLPath);
+    }
+  }
+  process.env.RWJS_CWD = cwd;
+};
+function setTomlSetting(section, setting, value) {
+  const redwoodTomlPath = getConfigPath();
+  const originalTomlContent = fs.readFileSync(redwoodTomlPath, "utf-8");
+  const redwoodTomlObject = toml.parse(originalTomlContent);
+  const sectionValue = redwoodTomlObject[section];
+  const existingValue = (
+    // I don't like this type cast, but I couldn't come up with a much better
+    // solution
+    sectionValue?.[setting]
+  );
+  if (existingValue === value) {
+    return;
+  }
+  let newTomlContent = originalTomlContent.replace(/\n$/, "") + `
+
+[${section}]
+  ${setting} = ${value}`;
+  const hasExistingSettingSection = !!redwoodTomlObject?.[section];
+  if (hasExistingSettingSection) {
+    const existingSectionSettings = Object.keys(redwoodTomlObject[section]);
+    let inSection = false;
+    let indentation = "";
+    let insertionIndex = 1;
+    let updateExistingValue = false;
+    let updateExistingCommentedValue = false;
+    const tomlLines = originalTomlContent.split("\n");
+    tomlLines.forEach((line, index) => {
+      if (line.startsWith(`[${section}]`)) {
+        inSection = true;
+        insertionIndex = index + 1;
+      } else {
+        if (/^\s*\[/.test(line)) {
+          inSection = false;
+        }
+        if (inSection && !updateExistingValue) {
+          for (const existingSectionSetting of existingSectionSettings) {
+            const matches = line.match(
+              new RegExp(`^(\\s*)${existingSectionSetting}\\s*=`, "i")
+            );
+            if (!updateExistingValue && matches) {
+              if (!updateExistingCommentedValue) {
+                indentation = matches[1];
+              }
+              if (existingSectionSetting === setting) {
+                updateExistingValue = true;
+                insertionIndex = index;
+                indentation = matches[1];
+              }
+            }
+            if (!updateExistingValue && !updateExistingCommentedValue && /^\s*\w+\s*=/.test(line)) {
+              insertionIndex = index + 1;
+            }
+          }
+          if (!updateExistingValue) {
+            const matchesComment = line.match(
+              new RegExp(`^(\\s*)#(\\s*)${setting}\\s*=`, "i")
+            );
+            if (matchesComment) {
+              const commentIndentation = matchesComment[1].length > matchesComment[2].length ? matchesComment[1] : matchesComment[2];
+              if (commentIndentation.length - 1 > indentation.length) {
+                indentation = commentIndentation;
+              }
+              updateExistingCommentedValue = true;
+              insertionIndex = index;
+            }
+          }
+        }
+      }
+    });
+    tomlLines.splice(
+      insertionIndex,
+      updateExistingValue || updateExistingCommentedValue ? 1 : 0,
+      `${indentation}${setting} = ${value}`
+    );
+    newTomlContent = tomlLines.join("\n");
+  }
+  fs.writeFileSync(redwoodTomlPath, newTomlContent);
+}
+export {
+  addEnvVar,
+  addEnvVarTask,
+  getGraphqlPath,
+  getInstalledRedwoodVersion,
+  graphFunctionDoesExist,
+  isTypeScriptProject,
+  setRedwoodCWD,
+  setTomlSetting,
+  updateTomlConfig,
+  updateTomlConfigTask
+};

package/dist/lib/version.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Check if the package at the given version is compatible with the current version of the user's RedwoodJS project. This is
+ * determined by checking if the package's engines.redwoodjs field intersects with the user's RedwoodJS version.
+ *
+ * If the preferred version is not compatible, the latest compatible version will be returned if one exists.
+ */
+export declare function getCompatibilityData(packageName: string, preferredVersionOrTag: string): Promise<{
+    preferred: {
+        tag: string | undefined;
+        version: string;
+    };
+    compatible: {
+        tag: string | undefined;
+        version: string;
+    };
+}>;
+//# sourceMappingURL=version.d.ts.map

package/dist/lib/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/lib/version.ts"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,MAAM,EACnB,qBAAqB,EAAE,MAAM;;;;;;;;;GA2F9B"}

package/dist/lib/version.js

@@ -0,0 +1,73 @@
+import fs from "fs";
+import path from "path";
+import semver from "semver";
+import { getPaths } from "@cedarjs/project-config";
+function getCorrespondingTag(version, distTags) {
+  return Object.entries(distTags).find(([_, v]) => v === version)?.[0];
+}
+async function getCompatibilityData(packageName, preferredVersionOrTag) {
+  const projectPackageJson = JSON.parse(
+    fs.readFileSync(path.join(getPaths().base, "package.json"), {
+      encoding: "utf8"
+    })
+  );
+  const projectRedwoodVersion = projectPackageJson.devDependencies["@cedarjs/core"];
+  const semverVersion = semver.parse(preferredVersionOrTag);
+  const isUsingTag = semverVersion === null;
+  const res = await fetch(`https://registry.npmjs.org/${packageName}`);
+  const packument = await res.json();
+  if (packument.error !== void 0) {
+    throw new Error(packument.error);
+  }
+  if (isUsingTag) {
+    if (packument["dist-tags"][preferredVersionOrTag] === void 0) {
+      throw new Error(
+        `The package '${packageName}' does not have a tag '${preferredVersionOrTag}'`
+      );
+    }
+  } else {
+    if (packument.versions[preferredVersionOrTag] === void 0) {
+      throw new Error(
+        `The package '${packageName}' does not have a version '${preferredVersionOrTag}'`
+      );
+    }
+  }
+  const preferredVersion = isUsingTag ? packument["dist-tags"][preferredVersionOrTag] : preferredVersionOrTag;
+  const packageRedwoodSpecification = packument.versions[preferredVersion].engines?.redwoodjs;
+  if (packageRedwoodSpecification !== void 0 && semver.intersects(projectRedwoodVersion, packageRedwoodSpecification)) {
+    const tag = getCorrespondingTag(preferredVersion, packument["dist-tags"]);
+    return {
+      preferred: {
+        tag,
+        version: preferredVersion
+      },
+      compatible: {
+        tag,
+        version: preferredVersion
+      }
+    };
+  }
+  const versions = semver.sort(Object.keys(packument.versions));
+  for (let i = versions.length - 1; i >= 0; i--) {
+    const redwoodVersionRequired = packument.versions[versions[i]].engines?.redwoodjs;
+    if (redwoodVersionRequired === void 0) {
+      continue;
+    }
+    if (semver.intersects(projectRedwoodVersion, redwoodVersionRequired)) {
+      return {
+        preferred: {
+          tag: getCorrespondingTag(preferredVersion, packument["dist-tags"]),
+          version: preferredVersion
+        },
+        compatible: {
+          tag: getCorrespondingTag(versions[i], packument["dist-tags"]),
+          version: versions[i]
+        }
+      };
+    }
+  }
+  throw new Error(`No compatible version of '${packageName}' was found`);
+}
+export {
+  getCompatibilityData
+};

package/dist/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/src/auth/__tests__/authFiles.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=authFiles.test.d.ts.map

package/dist/src/auth/__tests__/authFiles.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authFiles.test.d.ts","sourceRoot":"","sources":["../../../../src/auth/__tests__/authFiles.test.ts"],"names":[],"mappings":""}

package/dist/src/auth/__tests__/authTasks.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=authTasks.test.d.ts.map

package/dist/src/auth/__tests__/authTasks.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authTasks.test.d.ts","sourceRoot":"","sources":["../../../../src/auth/__tests__/authTasks.test.ts"],"names":[],"mappings":""}

package/dist/src/auth/__tests__/mockFsFiles.d.ts

@@ -0,0 +1,14 @@
+export declare const webAppTsx: string;
+export declare const graphqlTs: string;
+export declare const auth0WebAuthTsTemplate: string;
+export declare const clerkWebAuthTsTemplate: string;
+export declare const routesTsx: string;
+export declare const legacyAuthWebAppTsx: string;
+export declare const customApolloAppTsx: string;
+export declare const customPropsRoutesTsx: string;
+export declare const useAuthRoutesTsx: string;
+export declare const explicitReturnAppTsx: string;
+export declare const withoutRedwoodApolloAppTsx: string;
+export declare const withAuthDecoderGraphqlTs: string;
+export declare const nonStandardAuthDecoderGraphqlTs: string;
+//# sourceMappingURL=mockFsFiles.d.ts.map

package/dist/src/auth/__tests__/mockFsFiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockFsFiles.d.ts","sourceRoot":"","sources":["../../../../src/auth/__tests__/mockFsFiles.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,QAoBrB,CAAA;AAED,eAAO,MAAM,SAAS,QAoBrB,CAAA;AAED,eAAO,MAAM,sBAAsB,QAyBlC,CAAA;AAED,eAAO,MAAM,sBAAsB,QAkDlC,CAAA;AAED,eAAO,MAAM,SAAS,QAqBrB,CAAA;AAED,eAAO,MAAM,mBAAmB,QA4B/B,CAAA;AAED,eAAO,MAAM,kBAAkB,QAoB9B,CAAA;AAED,eAAO,MAAM,oBAAoB,QA8BhC,CAAA;AAED,eAAO,MAAM,gBAAgB,QAkC5B,CAAA;AAED,eAAO,MAAM,oBAAoB,QA+BhC,CAAA;AAED,eAAO,MAAM,0BAA0B,QAuBtC,CAAA;AAED,eAAO,MAAM,wBAAwB,QAwBpC,CAAA;AAED,eAAO,MAAM,+BAA+B,QAwB3C,CAAA"}

package/dist/src/auth/__tests__/setupHelpers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=setupHelpers.test.d.ts.map