@faststore/cli 3.99.1 → 4.0.0-dev.4

package/dist/index.js

@@ -1,21 +1,2254 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.commands = exports.run = void 0;
-const tslib_1 = require("tslib");
-var core_1 = require("@oclif/core");
-Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });
-const create_1 = tslib_1.__importDefault(require("./commands/create"));
-const dev_1 = tslib_1.__importDefault(require("./commands/dev"));
-const build_1 = tslib_1.__importDefault(require("./commands/build"));
-const start_1 = tslib_1.__importDefault(require("./commands/start"));
-const cms_sync_1 = tslib_1.__importDefault(require("./commands/cms-sync"));
-const test_1 = tslib_1.__importDefault(require("./commands/test"));
-exports.commands = {
-    create: create_1.default,
-    dev: dev_1.default,
-    build: build_1.default,
-    serve: start_1.default,
-    'cms-sync': cms_sync_1.default,
-    test: test_1.default,
+// src/index.ts
+import { run } from "@oclif/core";
+
+// src/commands/build.ts
+import { Args, Command, Flags } from "@oclif/core";
+import chalk5 from "chalk";
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import fsExtra4 from "fs-extra";
+import path6 from "path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+
+// src/utils/commands.ts
+import fsExtra from "fs-extra";
+import { spawnSync } from "child_process";
+import { join } from "path";
+import resolvePackage from "resolve-pkg";
+var { existsSync } = fsExtra;
+async function getPreferredPackageManager() {
+  let agent = "yarn";
+  const binNA = join(
+    await getPackageRootDir("@antfu/ni"),
+    (await getDepPackageJSON("@antfu/ni"))?.bin?.["na"] ?? ""
+  );
+  if (!binNA || fsExtra.existsSync(binNA) == false) return agent;
+  agent = spawnSync("node", [binNA, "?"], { encoding: "utf-8" })?.stdout.trim();
+  return agent;
+}
+async function getPackageRootDir(pkg, cwd = process.cwd(), depth = 30) {
+  let pkgPath = resolvePackage(pkg, { cwd });
+  if (!pkgPath) throw new Error(`Couldn't resolve package ${pkg}`);
+  let pkgJson = await loadPackageJsonAt(pkgPath);
+  while (pkgJson?.name !== pkg && --depth > 0) {
+    pkgPath = join(pkgPath, "..");
+    pkgJson = await loadPackageJsonAt(join(pkgPath, ".."));
+  }
+  if (pkgJson?.name !== pkg)
+    throw new Error(`Maximum depth search for package ${pkg} root exceed`);
+  return pkgPath;
+}
+async function loadPackageJsonAt(at) {
+  const file = "package.json", location = at?.endsWith(file) && at || at && join(at, file) || false;
+  if (location === false)
+    throw new Error(`Invalid searching of ${file} at ${at}`);
+  if (!existsSync(location)) return;
+  const content = await import(location, {
+    with: { type: "json" }
+  });
+  return content.default ?? content ?? {};
+}
+async function getDepPackageJSON(pkg) {
+  return await loadPackageJsonAt(await getPackageRootDir(pkg));
+}
+
+// src/utils/config.ts
+import chalk from "chalk";
+import { existsSync as existsSync2 } from "fs";
+import path2 from "path";
+
+// src/utils/directory.ts
+import path from "path";
+import { fileURLToPath } from "url";
+var getBasePath = (basePath) => {
+  if (basePath) {
+    return path.resolve(basePath);
+  }
+  return process.cwd();
+};
+var withBasePath = (basepath) => {
+  const tmpFolderName = ".faststore";
+  const getRoot = () => basepath;
+  const getCorePackagePath = () => path.dirname(
+    fileURLToPath(import.meta.resolve("@faststore/core", import.meta.url))
+  );
+  const customizationsDir = getRoot();
+  const tmpDir = path.join(getRoot(), tmpFolderName);
+  const userSrcDir = path.join(customizationsDir, "src");
+  const getPackagePath = (...packagePath) => path.join(customizationsDir, "node_modules", ...packagePath);
+  return {
+    getRoot,
+    getPackagePath,
+    userDir: customizationsDir,
+    userSrcDir,
+    userThemesFileDir: path.join(userSrcDir, "themes"),
+    userCMSDir: path.join(customizationsDir, "cms", "faststore"),
+    userLegacyStoreConfigFile: path.join(
+      customizationsDir,
+      "faststore.config.js"
+    ),
+    userStoreConfigFile: path.join(customizationsDir, "discovery.config.js"),
+    tmpSeoConfig: path.join(tmpDir, "next-seo.config.ts"),
+    tmpFolderName,
+    tmpDir,
+    tmpCustomizationsSrcDir: path.join(tmpDir, "src", "customizations", "src"),
+    tmpThemesCustomizationsFile: path.join(
+      tmpDir,
+      "src",
+      "customizations",
+      "src",
+      "themes",
+      "index.scss"
+    ),
+    tmpThemesPluginsFile: path.join(tmpDir, "src", "plugins", "index.scss"),
+    tmpCMSDir: (projectName = "faststore") => path.join(tmpDir, "cms", projectName),
+    tmpCMSWebhookUrlsFile: path.join(tmpDir, "cms-webhook-urls.json"),
+    tmpPagesDir: path.join(tmpDir, "src", "pages"),
+    tmpApiDir: path.join(tmpDir, "src", "pages", "api"),
+    tmpPluginsDir: path.join(tmpDir, "src", "plugins"),
+    tmpStoreConfigFile: path.join(
+      tmpDir,
+      "src",
+      "customizations",
+      "discovery.config.js"
+    ),
+    coreDir: getCorePackagePath(),
+    coreCMSDir: path.join(getCorePackagePath(), "cms", "faststore")
+  };
+};
+
+// src/utils/logger.ts
+var logger = new Proxy(console, {
+  get(target, prop) {
+    if (prop === "log") {
+      return (...args) => {
+        if (process.env.DISCOVERY_DEBUG === "true") {
+          target.log(...args);
+        }
+      };
+    }
+    return target[prop];
+  }
+});
+
+// src/utils/config.ts
+var configFileName = "discovery.config.js";
+async function getDiscoveryConfig(basePath) {
+  const { tmpDir } = withBasePath(basePath);
+  const configPaths = [
+    path2.join(tmpDir, configFileName),
+    path2.join(basePath, configFileName)
+  ];
+  for (const configPath of configPaths) {
+    if (existsSync2(configPath)) {
+      try {
+        const discoveryConfig = await import(configPath);
+        return discoveryConfig?.default ?? discoveryConfig;
+      } catch (error) {
+        logger.warn(
+          `${chalk.yellow("warning")} - Could not read config file: ${configPath}.`
+        );
+      }
+    }
+  }
+  return null;
+}
+function isLocalizationEnabled(config) {
+  return config?.localization?.enabled === true;
+}
+function validateContentSourceForLocalization(config) {
+  if (!isLocalizationEnabled(config)) {
+    return;
+  }
+  const currentContentSourceType = config?.contentSource?.type?.toUpperCase();
+  if (currentContentSourceType !== "CP") {
+    logger.error(
+      `
+${chalk.red("[Error]")} - Localization is enabled but contentSource is set to "${currentContentSourceType}".
+
+${chalk.cyan("Required Action:")}
+Update your ${chalk.bold("discovery.config.js")} file:
+
+  contentSource: {
+    type: ${chalk.green('"CP"')}
+  },
+
+${chalk.dim("When localization is enabled, Content Platform (CP) is required.")}
+`
+    );
+    process.exit(1);
+  }
+}
+async function checkAndValidateLocalization(basePath) {
+  const config = await getDiscoveryConfig(basePath);
+  if (!config) {
+    return false;
+  }
+  validateContentSourceForLocalization(config);
+  return isLocalizationEnabled(config);
+}
+
+// src/utils/deprecations.ts
+import { existsSync as existsSync3 } from "fs";
+import chalk2 from "chalk";
+function checkDeprecatedSecretFiles(basePath) {
+  const secretsFilePath = `${basePath}/secrets.hidden.json`;
+  const vtexEnvFilePath = `${basePath}/vtex.env`;
+  const secretsFileExists = existsSync3(secretsFilePath);
+  const vtexEnvFileExists = existsSync3(vtexEnvFilePath);
+  if (secretsFileExists || vtexEnvFileExists) {
+    const filesFound = [
+      secretsFileExists ? "secrets.hidden.json" : null,
+      vtexEnvFileExists ? "vtex.env" : null
+    ].filter(Boolean).join(" and ");
+    logger.warn(
+      `${chalk2.yellow("warning")} - Deprecated secret files detected: ${chalk2.bold(filesFound)}
+Note: 'vtex.env' should only be used for local development and not in production.
+For production environments, please configure your secrets directly in the FastStore WebOps Settings page.`
+    );
+    logger.log("");
+  }
+}
+
+// src/utils/generate.ts
+import chalk4 from "chalk";
+import fsExtra3 from "fs-extra";
+import path5 from "path";
+import ora from "ora";
+
+// src/utils/createNextjsPages.ts
+import fs from "fs";
+import path3 from "path";
+
+// src/utils/templates/myAccountPage.ts
+var myAccountPageTemplate = (pagePath) => `
+  import type { ComponentType } from 'react'
+  import RenderSections from 'src/components/cms/RenderSections'
+  import { default as GLOBAL_COMPONENTS } from 'src/components/cms/global/Components'
+  import CUSTOM_COMPONENTS from 'src/customizations/src/components'
+  import { MyAccountLayout } from 'src/components/account'
+  import {
+    getServerSideProps,
+    type MyAccountProps,
+  } from 'src/experimental/myAccountServerSideProps'
+  import DynamicPage from '${pagePath}';
+  import PageProvider from 'src/sdk/overrides/PageProvider'
+  /* A list of components that can be used in the CMS. */
+  const COMPONENTS: Record<string, ComponentType<any>> = {
+    ...GLOBAL_COMPONENTS,
+    ...CUSTOM_COMPONENTS,
+  }
+
+  function Page({ globalSections: globalSectionsProp, accountName, isRepresentative }: MyAccountProps) {
+    const { sections: globalSections, settings: globalSettings } = globalSectionsProp ?? {}
+
+    return (
+     <PageProvider context={{ globalSettings }}>
+        <RenderSections
+          globalSections={globalSections}
+          components={COMPONENTS}
+        >
+          <MyAccountLayout accountName={accountName} isRepresentative={isRepresentative}>
+            <DynamicPage />
+          </MyAccountLayout>
+        </RenderSections>
+      </PageProvider>
+    )
+  }
+
+  export { getServerSideProps }
+
+  export default Page
+`;
+
+// src/utils/createNextjsPages.ts
+var ALLOWED_PREFIX_PAGES = ["/pvt/account"];
+var createExternalPages = ({
+  customizationPagesDir,
+  corePagesDir,
+  baseCustomizationPagesDir
+}) => {
+  fs.readdirSync(customizationPagesDir).forEach((file) => {
+    const filePath = path3.join(customizationPagesDir, file);
+    const destinationPath = path3.join(corePagesDir, file);
+    if (fs.statSync(filePath).isDirectory()) {
+      if (!fs.existsSync(destinationPath)) {
+        fs.mkdirSync(destinationPath, { recursive: true });
+      }
+      return createExternalPages({
+        customizationPagesDir: filePath,
+        corePagesDir: destinationPath,
+        baseCustomizationPagesDir
+      });
+    }
+    const isReactFile = filePath.endsWith(".tsx");
+    const isDestinationAvailable = !fs.existsSync(destinationPath) && !fs.existsSync(
+      path3.join(destinationPath.replace(".tsx", ""), "index.tsx")
+    );
+    if (isReactFile && isDestinationAvailable) {
+      const externalPagePath = `src/customizations/src/pages${filePath.replace(baseCustomizationPagesDir, "").replace(".tsx", "")}`;
+      const content = myAccountPageTemplate(externalPagePath);
+      fs.writeFileSync(destinationPath, content);
+    }
+  });
+};
+function isAllowedPrefixPage(file) {
+  return ALLOWED_PREFIX_PAGES.some((prefix) => file.startsWith(prefix));
+}
+function createNextJsPages(basePath) {
+  const { tmpDir } = withBasePath(basePath);
+  const corePagesDir = path3.join(tmpDir, "src/pages");
+  const customizationPagesDir = path3.join(
+    tmpDir,
+    "src/customizations/src/pages"
+  );
+  if (!fs.existsSync(customizationPagesDir)) {
+    return;
+  }
+  const allPagesAreAllowed = ({
+    basePath: basePath2,
+    dirPath
+  }) => {
+    const items = fs.readdirSync(dirPath, { withFileTypes: true });
+    return items.every((item) => {
+      const itemPath = path3.join(dirPath, item.name);
+      if (item.isDirectory()) {
+        return allPagesAreAllowed({ basePath: basePath2, dirPath: itemPath });
+      }
+      if (!item.isFile()) {
+        return false;
+      }
+      const isNextPage = /\.(js|jsx|ts|tsx)$/.test(item.name);
+      if (!isNextPage) {
+        return false;
+      }
+      const relativePath = path3.relative(basePath2, itemPath);
+      const normalizedPath = "/" + relativePath.replace(/\\/g, "/").replace(/\.(js|jsx|ts|tsx)$/, "");
+      return isAllowedPrefixPage(normalizedPath);
+    });
+  };
+  const pagesAreAllowed = allPagesAreAllowed({
+    basePath: customizationPagesDir,
+    dirPath: customizationPagesDir
+  });
+  if (!pagesAreAllowed) {
+    throw new Error(
+      `Only these prefix pages: (${ALLOWED_PREFIX_PAGES.join(", ")}) are allowed`
+    );
+  }
+  createExternalPages({
+    customizationPagesDir,
+    corePagesDir,
+    baseCustomizationPagesDir: customizationPagesDir
+  });
+}
+
+// src/utils/runCommandSync.ts
+import chalk3 from "chalk";
+import { execSync } from "child_process";
+var showError = ({
+  message,
+  cmd,
+  error
+}) => {
+  logger.error(`${chalk3.red("error")} - ${message}`);
+  if (cmd && error) {
+    logger.log(
+      `${chalk3.magenta("DEBUG")} - $ ${JSON.stringify(cmd, null, 2)} error root \u2193`
+    );
+    logger.log(error.stdout?.toString());
+  }
+  process.exit(1);
+};
+var showWarning = ({
+  message,
+  cmd,
+  error
+}) => {
+  logger.warn(`${chalk3.yellow("warn")} - ${message}`);
+  if (cmd && error) {
+    logger.log(
+      `${chalk3.magenta("DEBUG")} - $ ${JSON.stringify(cmd, null, 2)} warn root \u2193`
+    );
+    logger.log(error.stdout?.toString());
+  }
+};
+var runCommandSync = ({
+  cmd,
+  errorMessage,
+  throws,
+  cwd
+}) => {
+  const debug = process.env.DISCOVERY_DEBUG === "true" ? true : false;
+  try {
+    logger.log(`[STARTED] ${cmd}`);
+    const res = execSync(
+      debug ? `${cmd} --debug --verbose 2>&1` : `${cmd} 2>&1`,
+      {
+        stdio: "pipe",
+        cwd
+      }
+    );
+    logger.log(`[STATUS] ${res?.toString() ?? "Unknown"}`);
+    logger.log(`[FINISHED] ${cmd}`);
+  } catch (error) {
+    const sanitizedError = debug ? error : void 0;
+    if (throws === "warning") {
+      showWarning({ message: errorMessage, cmd, error: sanitizedError });
+    } else {
+      showError({ message: errorMessage, cmd, error: sanitizedError });
+    }
+  }
+};
+
+// src/utils/dependencies.ts
+async function installDependencies({
+  dependencies,
+  cwd,
+  errorMessage
+}) {
+  const packageManager = await getPreferredPackageManager();
+  const installCommand = packageManager === "npm" ? "install" : "add";
+  runCommandSync({
+    cmd: `${packageManager} ${installCommand} ${dependencies.join(" ")}`,
+    errorMessage,
+    throws: "error",
+    cwd
+  });
+}
+
+// src/utils/plugins.ts
+import fsExtra2 from "fs-extra";
+import path4 from "path";
+var { copySync, existsSync: existsSync4, mkdirSync, readdirSync, writeFileSync } = fsExtra2;
+var PLUGIN_CONFIG_FILE = "plugin.config.js";
+var sanitizePluginName = (pluginName, pascalCase = false) => {
+  const sanitized = pluginName.split("/")[1];
+  if (pascalCase) {
+    return sanitized.toLowerCase().split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
+  return sanitized;
+};
+var getPluginName = (plugin) => {
+  if (typeof plugin === "string") {
+    return plugin;
+  }
+  return Object.keys(plugin)[0];
+};
+var getPluginCustomConfig = (plugin) => {
+  if (typeof plugin === "string") {
+    return {};
+  }
+  return plugin[getPluginName(plugin)];
+};
+var getPluginSrcPath = async (basePath, pluginName) => {
+  const { getPackagePath } = withBasePath(basePath);
+  return getPackagePath(pluginName, "src");
+};
+var getPluginsList = async (basePath) => {
+  const { tmpStoreConfigFile } = withBasePath(basePath);
+  try {
+    const {
+      default: { plugins = [] }
+    } = await import(tmpStoreConfigFile);
+    return plugins;
+  } catch (error) {
+    logger.error(`Could not load plugins from store config`);
+  }
+  return [];
+};
+var copyPluginsSrc = async (basePath, plugins) => {
+  const { tmpPluginsDir } = withBasePath(basePath);
+  logger.log("Copying plugins files");
+  plugins.forEach(async (plugin) => {
+    const pluginName = getPluginName(plugin);
+    const pluginSrcPath = await getPluginSrcPath(
+      basePath,
+      getPluginName(pluginName)
+    );
+    const pluginDestPath = path4.join(
+      tmpPluginsDir,
+      sanitizePluginName(pluginName)
+    );
+    copySync(pluginSrcPath, pluginDestPath);
+    logger.log(`Copied ${pluginName} files`);
+  });
+};
+var copyPluginPublicFiles = async (basePath, plugins) => {
+  const { tmpDir, getPackagePath } = withBasePath(basePath);
+  logger.log("Copying plugin public files");
+  plugins.forEach(async (plugin) => {
+    const pluginName = getPluginName(plugin);
+    const pluginPath = getPackagePath(getPluginName(pluginName));
+    try {
+      if (existsSync4(`${pluginPath}/public`)) {
+        copySync(`${pluginPath}/public`, `${tmpDir}/public`, {
+          dereference: true,
+          overwrite: true
+        });
+        logger.log(`Plugin public files copied`);
+      }
+    } catch (e) {
+      logger.error(e);
+    }
+  });
+};
+var getPluginPageFileContent = (pluginName, pageName, appLayout) => `
+// GENERATED FILE
+// @ts-nocheck
+import * as page from 'src/plugins/${pluginName}/pages/${pageName}'
+${appLayout ? `import { getGlobalSectionsData } from 'src/components/cms/GlobalSections'` : ``}
+${appLayout ? `import RenderSections from 'src/components/cms/RenderSections'` : ``}
+import { withLocaleValidationSSR } from 'src/utils/localization/withLocaleValidation'
+
+async function getServerSidePropsBase(${appLayout ? "{ previewData, ...otherProps }" : "otherProps"}) {
+  const noop = async function() {}
+  const loaderData = await (page.loader || noop)(otherProps)
+${appLayout ? `const { sections = [] } = await getGlobalSectionsData(previewData)` : ``}
+
+  return {
+    props: {
+        data: loaderData,
+        ${appLayout ? "globalSections: sections" : ``}
+    }
+  }
+}
+
+export const getServerSideProps = withLocaleValidationSSR(getServerSidePropsBase)
+export default function Page(props) {
+  ${appLayout ? `return <RenderSections globalSections={props.globalSections}>
+            {page.default(props.data)}
+          </RenderSections>` : `return page.default(props.data)`}
+}
+      `;
+var generatePluginPages = async (basePath, plugins) => {
+  const { tmpPagesDir, getPackagePath } = withBasePath(basePath);
+  logger.log("Generating plugin pages");
+  plugins.forEach(async (plugin) => {
+    const pluginName = getPluginName(plugin);
+    const pluginConfigPath = getPackagePath(pluginName, PLUGIN_CONFIG_FILE);
+    const { default: pluginConfig } = await import(pluginConfigPath);
+    const { pages: pagesCustom } = getPluginCustomConfig(plugin);
+    const pagesConfig = {
+      ...pluginConfig.pages ?? {},
+      ...pagesCustom
+    };
+    const pages = Object.keys(pagesConfig);
+    pages.forEach(async (pageName) => {
+      const paths = pagesConfig[pageName].path.split("/");
+      const pageFile = paths.pop();
+      const pagePaths = paths;
+      const pagePath = path4.join(tmpPagesDir, ...pagePaths, pageFile + ".tsx");
+      const fileContent = getPluginPageFileContent(
+        sanitizePluginName(pluginName),
+        pageName,
+        pagesConfig[pageName].appLayout
+      );
+      mkdirSync(path4.dirname(pagePath), { recursive: true });
+      writeFileSync(pagePath, fileContent);
+    });
+  });
+};
+async function addPluginsSections(basePath, plugins) {
+  const { tmpPluginsDir, getPackagePath } = withBasePath(basePath);
+  logger.log("Adding plugin sections");
+  const indexPluginsOverrides = plugins.filter(
+    (plugin) => existsSync4(
+      getPackagePath(getPluginName(plugin), "src", "components", "index.ts")
+    )
+  ).map((plugin) => {
+    const pluginReference = sanitizePluginName(getPluginName(plugin), true) + "Components";
+    return {
+      import: `import { default as ${pluginReference} } from 'src/plugins/${sanitizePluginName(getPluginName(plugin))}/components'`,
+      pluginReference
+    };
+  });
+  const pluginsImportFileContent = `
+  ${indexPluginsOverrides.map((plugin) => plugin.import).join("\n")}
+
+  export default {
+    ${indexPluginsOverrides.map((plugin) => `...${plugin.pluginReference}`).join(",\n")}
+  }
+  `;
+  const sectionPath = path4.join(tmpPluginsDir, "index.ts");
+  writeFileSync(sectionPath, pluginsImportFileContent);
+  logger.log("Writing plugins overrides");
+  logger.log(sectionPath);
+  logger.log(pluginsImportFileContent);
+}
+async function addPluginsOverrides(basePath, plugins) {
+  const { tmpPluginsDir, getPackagePath } = withBasePath(basePath);
+  logger.log("Adding plugin overrides");
+  plugins.map((plugin) => ({
+    pluginName: getPluginName(plugin),
+    pluginOverridesPath: getPackagePath(
+      getPluginName(plugin),
+      "src",
+      "components",
+      "overrides"
+    )
+  })).filter(({ pluginOverridesPath }) => existsSync4(pluginOverridesPath)).reverse().forEach(({ pluginName, pluginOverridesPath }) => {
+    const overrideFilesAlreadyCopied = [];
+    const sanitizedPluginName = sanitizePluginName(pluginName);
+    const overrideFiles = readdirSync(pluginOverridesPath);
+    overrideFiles.filter((file) => !overrideFilesAlreadyCopied.includes(file)).forEach((overrideFileName) => {
+      const overrideFileContent = `export { override } from 'src/plugins/${sanitizedPluginName}/components/overrides/${overrideFileName.split(".")[0]}'`;
+      writeFileSync(
+        path4.join(tmpPluginsDir, "overrides", overrideFileName),
+        overrideFileContent
+      );
+      overrideFilesAlreadyCopied.push(overrideFileName);
+    });
+  });
+}
+var addPluginsTheme = async (basePath, plugins) => {
+  const { getPackagePath, tmpThemesPluginsFile } = withBasePath(basePath);
+  const pluginImportsContent = plugins.filter(
+    (plugin) => existsSync4(
+      getPackagePath(getPluginName(plugin), "src", "themes", "index.scss")
+    )
+  ).map((plugin) => `@import "${getPluginName(plugin)}/src/themes/index.scss"`).join("\n");
+  writeFileSync(tmpThemesPluginsFile, pluginImportsContent);
+};
+var getPluginAPIFileContent = (pluginName, apiName) => `
+// GENERATED FILE
+// @ts-nocheck
+import apiHandle from 'src/plugins/${pluginName}/apis/${apiName}'
+import { NextApiRequest, NextApiResponse } from "next/types"
+
+export default function handle(req: NextApiRequest, res: NextApiResponse) {
+  return apiHandle(req, res)
+}
+`;
+var generatePluginApis = async (basePath, plugins) => {
+  const { tmpApiDir, getPackagePath } = withBasePath(basePath);
+  logger.log("Generating plugin APIs");
+  plugins.forEach(async (plugin) => {
+    const pluginName = getPluginName(plugin);
+    const pluginConfigPath = getPackagePath(pluginName, PLUGIN_CONFIG_FILE);
+    const { default: pluginConfig } = await import(pluginConfigPath);
+    const { apis: apisCustom } = getPluginCustomConfig(plugin);
+    const apisConfig = {
+      ...pluginConfig.apis ?? {},
+      ...apisCustom
+    };
+    const apis = Object.keys(apisConfig);
+    apis.forEach(async (apiName) => {
+      const paths = apisConfig[apiName].path.split("/");
+      const apiFile = paths.pop();
+      const apiPaths = paths;
+      const apiPath = path4.join(
+        tmpApiDir,
+        "plugins",
+        ...apiPaths,
+        apiFile + ".ts"
+      );
+      const fileContent = getPluginAPIFileContent(
+        sanitizePluginName(pluginName),
+        apiName
+      );
+      mkdirSync(path4.dirname(apiPath), { recursive: true });
+      writeFileSync(apiPath, fileContent);
+    });
+  });
+};
+var installPlugins = async (basePath) => {
+  const plugins = await getPluginsList(basePath);
+  copyPluginsSrc(basePath, plugins);
+  copyPluginPublicFiles(basePath, plugins);
+  generatePluginPages(basePath, plugins);
+  generatePluginApis(basePath, plugins);
+  addPluginsSections(basePath, plugins);
+  addPluginsOverrides(basePath, plugins);
+  addPluginsTheme(basePath, plugins);
+};
+
+// src/utils/generate.ts
+var {
+  copyFileSync,
+  copySync: copySync2,
+  existsSync: existsSync5,
+  mkdirsSync,
+  moveSync,
+  readFileSync,
+  readdirSync: readdirSync2,
+  removeSync,
+  writeFileSync: writeFileSync2,
+  writeJsonSync
+} = fsExtra3;
+var ignorePaths = [
+  "package.json",
+  "node_modules",
+  "cypress.config.ts",
+  "base.jsonc"
+  // CP special file, it must not be copied to the merchants' temp dir
+];
+function createTmpFolder(basePath) {
+  const { tmpDir, tmpFolderName } = withBasePath(basePath);
+  try {
+    if (existsSync5(tmpDir)) {
+      removeSync(tmpDir);
+    }
+    mkdirsSync(tmpDir);
+    logger.log(
+      `${chalk4.green("success")} - Temporary folder ${chalk4.dim(
+        tmpFolderName
+      )} created`
+    );
+  } catch (err) {
+    logger.error(`${chalk4.red("error")} - ${err}`);
+  }
+}
+function filterAndCopyPackageJson(basePath) {
+  const { coreDir, tmpDir } = withBasePath(basePath);
+  const { exports: _, ...filteredFileContent } = JSON.parse(
+    readFileSync(path5.join(coreDir, "package.json"), "utf8")
+  );
+  filteredFileContent.name = "dot-faststore";
+  filteredFileContent.scripts = {
+    ...filteredFileContent.scripts,
+    generate: "faststore generate",
+    build: "next build --webpack",
+    serve: "next serve",
+    dev: "next dev --webpack",
+    "dev-only": "next dev --webpack",
+    predev: "na run partytown",
+    prebuild: "na run partytown"
+  };
+  writeJsonSync(path5.join(tmpDir, "package.json"), filteredFileContent, {
+    spaces: 2
+  });
+}
+var TS_CONFIG_STRICT_RULES_ENABLED = ["noImplicitAny"];
+function disableTsConfigStrictRules(basePath) {
+  const { coreDir, tmpDir } = withBasePath(basePath);
+  const coreTsConfigPath = path5.join(coreDir, "tsconfig.json");
+  const coreTsConfigFile = readFileSync(coreTsConfigPath, "utf8");
+  const tsConfig = JSON.parse(coreTsConfigFile);
+  TS_CONFIG_STRICT_RULES_ENABLED.forEach((strictRule) => {
+    tsConfig.compilerOptions[strictRule] = false;
+  });
+  writeJsonSync(path5.join(tmpDir, "tsconfig.json"), tsConfig, {
+    spaces: 2
+  });
+}
+function copyCoreFiles(basePath) {
+  const { coreDir, tmpDir } = withBasePath(basePath);
+  try {
+    copySync2(coreDir, tmpDir, {
+      dereference: true,
+      filter(src) {
+        const fileOrDirName = path5.basename(src);
+        const shouldCopy = fileOrDirName ? !ignorePaths.includes(fileOrDirName) : true;
+        return shouldCopy;
+      }
+    });
+    filterAndCopyPackageJson(basePath);
+    disableTsConfigStrictRules(basePath);
+    logger.log(`${chalk4.green("success")} - Core files copied`);
+  } catch (e) {
+    logger.error(e);
+  }
+}
+function copyPublicFiles(basePath) {
+  const { userDir, tmpDir } = withBasePath(basePath);
+  const allowList = ["json", "txt", "xml", "ico", "public", "svg"];
+  try {
+    if (existsSync5(`${userDir}/public`)) {
+      copySync2(`${userDir}/public`, `${tmpDir}/public`, {
+        dereference: true,
+        overwrite: true,
+        filter: (src) => {
+          const allow = allowList.some((ext) => src.endsWith(ext));
+          return allow;
+        }
+      });
+      logger.log(`${chalk4.green("success")} - Public files copied`);
+    }
+  } catch (e) {
+    logger.error(e);
+  }
+}
+async function copyCypressFiles(basePath) {
+  const { userDir, userStoreConfigFile, userLegacyStoreConfigFile, tmpDir } = withBasePath(basePath);
+  try {
+    if (existsSync5(`${userDir}/cypress.json`)) {
+      copySync2(`${userDir}/cypress.json`, `${tmpDir}/cypress.json`, {
+        dereference: true
+      });
+    }
+    if (existsSync5(`${userDir}/cypress.config.ts`)) {
+      copySync2(`${userDir}/cypress.config.ts`, `${tmpDir}/cypress.config.ts`, {
+        dereference: true
+      });
+    }
+    let userStoreConfig;
+    if (existsSync5(userStoreConfigFile)) {
+      userStoreConfig = (await import(path5.resolve(userStoreConfigFile)))?.default;
+    } else if (existsSync5(userLegacyStoreConfigFile)) {
+      userStoreConfig = (await import(path5.resolve(userLegacyStoreConfigFile)))?.default;
+    } else {
+      logger.info(
+        `${chalk4.blue(
+          "info"
+        )} - No store config file was found in the root directory`
+      );
+    }
+    if (existsSync5(`${userDir}/cypress`) && userStoreConfig?.experimental?.enableCypressExtension) {
+      copySync2(`${userDir}/cypress`, `${tmpDir}/cypress`, {
+        overwrite: true,
+        dereference: true
+      });
+      logger.log(`${chalk4.green("success")} - Cypress test files copied`);
+    }
+    if (userStoreConfig?.experimental?.cypressVersion > 9) {
+      copySync2(
+        `${tmpDir}/cypress/support/index.js`,
+        `${tmpDir}/cypress/support/e2e.js`,
+        { overwrite: false }
+      );
+    }
+  } catch (e) {
+    logger.error(e);
+  }
+}
+function copyUserStarterToCustomizations(basePath) {
+  const {
+    userSrcDir,
+    tmpCustomizationsSrcDir,
+    userLegacyStoreConfigFile,
+    userStoreConfigFile,
+    tmpStoreConfigFile
+  } = withBasePath(basePath);
+  try {
+    if (existsSync5(userSrcDir) && readdirSync2(userSrcDir).length > 0) {
+      copySync2(userSrcDir, tmpCustomizationsSrcDir, { dereference: true });
+      createNextJsPages(basePath);
+    }
+    if (existsSync5(userStoreConfigFile)) {
+      copySync2(userStoreConfigFile, tmpStoreConfigFile, { dereference: true });
+    } else if (existsSync5(userLegacyStoreConfigFile)) {
+      copySync2(userLegacyStoreConfigFile, tmpStoreConfigFile, {
+        dereference: true
+      });
+    } else {
+      logger.info(
+        `${chalk4.blue(
+          "info"
+        )} - No store config file was found in the root directory`
+      );
+    }
+    logger.log(`${chalk4.green("success")} - Starter files copied`);
+  } catch (err) {
+    logger.error(`${chalk4.red("error")} - ${err}`);
+  }
+}
+async function createCmsWebhookUrlsJsonFile(basePath) {
+  const {
+    userStoreConfigFile,
+    userLegacyStoreConfigFile,
+    tmpCMSWebhookUrlsFile
+  } = withBasePath(basePath);
+  let userStoreConfig;
+  if (existsSync5(userStoreConfigFile)) {
+    userStoreConfig = (await import(path5.resolve(userStoreConfigFile)))?.default;
+  } else if (existsSync5(userLegacyStoreConfigFile)) {
+    userStoreConfig = (await import(path5.resolve(userLegacyStoreConfigFile)))?.default;
+  } else {
+    logger.info(
+      `${chalk4.blue(
+        "info"
+      )} - No store config file was found in the root directory`
+    );
+  }
+  if (userStoreConfig?.vtexHeadlessCms && userStoreConfig.vtexHeadlessCms?.webhookUrls) {
+    const { webhookUrls } = userStoreConfig?.vtexHeadlessCms;
+    try {
+      writeJsonSync(tmpCMSWebhookUrlsFile, { urls: webhookUrls }, { spaces: 2 });
+      logger.log(`${chalk4.green("success")} - CMS webhook URLs file created`);
+    } catch (err) {
+      logger.error(`${chalk4.red("error")} - ${err}`);
+    }
+  } else {
+    logger.info(`${chalk4.blue("info")} - No CMS webhook URLs were provided`);
+  }
+}
+async function copyTheme(basePath) {
+  const {
+    userStoreConfigFile,
+    userThemesFileDir,
+    tmpThemesCustomizationsFile,
+    userLegacyStoreConfigFile
+  } = withBasePath(basePath);
+  const storeConfigFile = existsSync5(userStoreConfigFile) && userStoreConfigFile || existsSync5(userLegacyStoreConfigFile) && userLegacyStoreConfigFile;
+  const userStoreConfigFilePath = storeConfigFile && path5.resolve(storeConfigFile);
+  const importedStoreConfig = userStoreConfigFilePath && await import(userStoreConfigFilePath);
+  const storeConfig = userStoreConfigFilePath && (importedStoreConfig?.default || importedStoreConfig);
+  if (!storeConfig)
+    logger.info(
+      `${chalk4.blue(
+        "info"
+      )} - No store config file was found in the root directory`
+    );
+  if (storeConfig.theme) {
+    const customTheme = path5.join(
+      userThemesFileDir,
+      `${storeConfig.theme}.scss`
+    );
+    if (existsSync5(customTheme)) {
+      try {
+        copyFileSync(customTheme, tmpThemesCustomizationsFile);
+        logger.log(
+          `${chalk4.green("success")} - ${storeConfig.theme} theme has been applied`
+        );
+      } catch (err) {
+        logger.error(`${chalk4.red("error")} - ${err}`);
+      }
+    } else {
+      logger.info(
+        `${chalk4.blue("info")} - The ${storeConfig.theme} theme was added to the config file but the ${storeConfig.theme}.scss file does not exist in the themes folder. Read more: https://developers.vtex.com/docs/guides/faststore/themes-overview`
+      );
+    }
+  } else if (existsSync5(userThemesFileDir) && readdirSync2(userThemesFileDir).length > 0) {
+    logger.info(
+      `${chalk4.blue(
+        "info"
+      )} - The theme needs to be added to the config file to be applied. Read more: https://www.faststore.dev/docs/themes/overview`
+    );
+  }
+}
+function updateBuildTime(basePath) {
+  try {
+    const { tmpSeoConfig } = withBasePath(basePath);
+    let config = readFileSync(tmpSeoConfig, "utf8");
+    const newBuildTime = (/* @__PURE__ */ new Date()).toISOString();
+    config = config.replace(
+      /const buildTime = .*?;/,
+      `const buildTime = '${newBuildTime}';`
+    );
+    writeFileSync2(tmpSeoConfig, config);
+    logger.log(`${chalk4.green("success")} - Build time updated`, newBuildTime);
+  } catch (error) {
+    logger.error(`${chalk4.red("error")} - Updating build time:`, error);
+  }
+}
+async function checkDependencies(basePath, packagesToCheck) {
+  const { coreDir, getRoot } = withBasePath(basePath);
+  const corePackageJsonPath = path5.join(coreDir, "package.json");
+  const rootPackageJsonPath = path5.join(getRoot(), "package.json");
+  const { default: corePackageJson } = await import(corePackageJsonPath, {
+    with: { type: "json" }
+  });
+  const { default: rootPackageJson } = await import(rootPackageJsonPath, {
+    with: { type: "json" }
+  });
+  packagesToCheck.forEach((packageName) => {
+    const coreVersion = corePackageJson.devDependencies[packageName] || corePackageJson.dependencies[packageName];
+    const rootVersion = rootPackageJson.devDependencies[packageName] || rootPackageJson.dependencies[packageName];
+    if (!coreVersion || !rootVersion) {
+      logger.warn(
+        `${chalk4.yellow(
+          "warning"
+        )} - Package ${packageName} not found in both core or root dependencies.`
+      );
+    } else if (coreVersion !== rootVersion) {
+      logger.warn(
+        `${chalk4.yellow(
+          "warning"
+        )} - Version mismatch detected for ${packageName}.
+          Core: ${coreVersion}, Customization: ${rootVersion}. Please align both versions to prevent issues`
+      );
+    }
+  });
+}
+function updateNextConfig(basePath) {
+  const { tmpDir } = withBasePath(basePath);
+  const nextConfigPath = path5.join(tmpDir, "next.config.js");
+  let nextConfigData = String(readFileSync(nextConfigPath));
+  nextConfigData = nextConfigData.replace(
+    /outputFileTracingRoot\:\s+(.*),/,
+    `outputFileTracingRoot: '${process.cwd()}',`
+  );
+  writeFileSync2(nextConfigPath, nextConfigData);
+}
+function getCurrentUserStoreConfigFile(basePath) {
+  const { userStoreConfigFile, userLegacyStoreConfigFile } = withBasePath(basePath);
+  if (existsSync5(userStoreConfigFile)) {
+    return userStoreConfigFile;
+  }
+  if (existsSync5(userLegacyStoreConfigFile)) {
+    return userLegacyStoreConfigFile;
+  }
+  return null;
+}
+async function validateAndInstallMissingDependencies(basePath) {
+  const { userDir } = withBasePath(basePath);
+  const currentUserStoreConfigFile = getCurrentUserStoreConfigFile(basePath);
+  if (!currentUserStoreConfigFile) {
+    return;
+  }
+  const { default: userStoreConfig } = await import(currentUserStoreConfigFile);
+  const { default: userPackageJson } = await import(path5.join(userDir, "package.json"), {
+    with: { type: "json" }
+  });
+  const missingDependencies = [];
+  if (userStoreConfig?.experimental?.preact) {
+    missingDependencies.push({
+      feature: "Preact",
+      dependencies: ["preact@10.23.1", "preact-render-to-string@6.5.8"]
+    });
+  }
+  missingDependencies.forEach(async ({ feature, dependencies }) => {
+    const dependenciesToInstall = dependencies.filter((dependency) => {
+      const dependencyName = dependency.split("@")[0];
+      return !userPackageJson.dependencies[dependencyName];
+    });
+    if (dependenciesToInstall.length > 0) {
+      const spinner = ora(
+        `Installing ${feature} missing dependencies
+`
+      ).start();
+      await installDependencies({
+        dependencies: dependenciesToInstall,
+        cwd: userDir,
+        errorMessage: `failed to install ${feature} dependencies`
+      });
+      spinner.stop();
+    }
+  });
+}
+var DISABLED_PROXY_FILENAME = "proxy__DISABLED.ts";
+function toggleProxyByLocalizationFlag(basePath, localizationEnabled) {
+  try {
+    const { tmpDir } = withBasePath(basePath);
+    const proxyPath = path5.join(tmpDir, "src", "proxy.ts");
+    const disabledPath = path5.join(tmpDir, "src", DISABLED_PROXY_FILENAME);
+    const shouldEnableProxy = existsSync5(disabledPath) && !existsSync5(proxyPath);
+    const shouldDisableProxy = existsSync5(proxyPath);
+    if (localizationEnabled && shouldEnableProxy) {
+      moveSync(disabledPath, proxyPath);
+    } else if (!localizationEnabled && shouldDisableProxy) {
+      moveSync(proxyPath, disabledPath);
+    }
+  } catch (error) {
+    logger.error(error);
+    throw error;
+  }
+}
+async function enableSearchSSR(basePath) {
+  const storeConfigPath = getCurrentUserStoreConfigFile(basePath);
+  if (!storeConfigPath) {
+    return;
+  }
+  const { default: storeConfig } = await import(storeConfigPath);
+  if (!storeConfig.experimental.enableSearchSSR) {
+    return;
+  }
+  const { tmpDir } = withBasePath(basePath);
+  const searchPagePath = path5.join(tmpDir, "src", "pages", "s.tsx");
+  const searchPageData = String(readFileSync(searchPagePath));
+  const searchPageWithSSR = searchPageData.replaceAll(
+    "getStaticProps",
+    "getServerSideProps"
+  );
+  writeFileSync2(searchPagePath, searchPageWithSSR);
+}
+async function generate(options) {
+  const { basePath, setup = false } = options;
+  let setupPromise = null;
+  await validateAndInstallMissingDependencies(basePath);
+  if (setup) {
+    setupPromise = Promise.all([
+      createTmpFolder(basePath),
+      copyCoreFiles(basePath),
+      copyCypressFiles(basePath),
+      copyPublicFiles(basePath),
+      updateNextConfig(basePath)
+    ]);
+  }
+  await Promise.all([
+    setupPromise,
+    checkDependencies(basePath, ["typescript"]),
+    enableSearchSSR(basePath),
+    updateBuildTime(basePath),
+    copyUserStarterToCustomizations(basePath),
+    copyTheme(basePath),
+    createCmsWebhookUrlsJsonFile(basePath),
+    installPlugins(basePath)
+  ]);
+}
+
+// src/commands/build.ts
+var { copySync: copySync3, moveSync: moveSync2, readdirSync: readdirSync3, removeSync: removeSync2 } = fsExtra4;
+var Build = class _Build extends Command {
+  static args = {
+    account: Args.string({
+      description: "The account for which the Discovery is running. Currently noop."
+    }),
+    path: Args.string({
+      description: "The path where the FastStore being built is. Defaults to cwd."
+    })
+  };
+  static flags = {
+    ["no-verify"]: Flags.boolean({
+      description: "Skips verification of faststore dependencies version string to prevent usage of packages outside npm registry."
+    })
+  };
+  async run() {
+    const { args, flags } = await this.parse(_Build);
+    const basePath = getBasePath(args.path);
+    checkDeprecatedSecretFiles(basePath);
+    if (!flags["no-verify"]) {
+      const invalidPackages = await checkDeps(basePath);
+      invalidPackages.forEach(
+        (pkg) => logger.warn(
+          `${chalk5.yellow(
+            "warning"
+          )} - Dependency ${pkg} has invalid version signature. Please use a semver like ^1.0.0 (check the official releases on https://github.com/vtex/faststore)`
+        )
+      );
+    }
+    const { tmpDir } = withBasePath(basePath);
+    const packageManager = await getPreferredPackageManager();
+    const binCli = path6.join(
+      fileURLToPath2(
+        import.meta.resolve("@faststore/cli/runner", import.meta.url)
+      )
+    );
+    let scriptResult = spawnSync2("node", [binCli, "generate", basePath], {
+      stdio: "inherit"
+    });
+    if (scriptResult.error || scriptResult.status !== 0) {
+      throw "Error: Cant run generate" + (scriptResult.error?.message ?? "");
+    }
+    scriptResult = spawnSync2("node", [binCli, "cache-graphql", basePath], {
+      stdio: "inherit"
+    });
+    if (scriptResult.error || scriptResult.status !== 0) {
+      throw "Error: Unable to run cache-graphql" + (scriptResult.error?.message ?? "");
+    }
+    scriptResult = spawnSync2("node", [binCli, "generate-i18n", basePath], {
+      stdio: "inherit"
+    });
+    if (scriptResult.error || scriptResult.status !== 0) {
+      throw "Error: Unable to run generate-i18n" + (scriptResult.error?.message ?? "");
+    }
+    const config = await getDiscoveryConfig(basePath);
+    const localizationEnabled = config?.localization?.enabled === true;
+    toggleProxyByLocalizationFlag(basePath, localizationEnabled);
+    scriptResult = spawnSync2(`${packageManager} run build`, {
+      shell: true,
+      cwd: tmpDir,
+      stdio: "inherit"
+    });
+    if (scriptResult.status && scriptResult.status !== 0) {
+      process.exit(scriptResult.status);
+    }
+    await normalizeStandaloneBuildDir(basePath);
+    await copyResources(basePath);
+  }
+};
+async function copyResource(from, to) {
+  try {
+    if (existsSync6(to)) {
+      removeSync2(to);
+    }
+    copySync3(from, to);
+    console.log(
+      `${chalk5.green("success")} - ${chalk5.dim(from)} copied to ${chalk5.dim(
+        to
+      )}`
+    );
+  } catch (err) {
+    console.error(`${chalk5.red("error")} - ${err}`);
+  }
+}
+async function normalizeStandaloneBuildDir(basePath) {
+  const { tmpDir } = withBasePath(basePath);
+  const isRunningFromMonorepo = process.cwd() !== basePath;
+  const prefix = isRunningFromMonorepo ? `${path6.relative(process.cwd(), basePath).replace(/\\/g, "/")}/` : "";
+  if (existsSync6(`${tmpDir}/.next/standalone/${prefix}.faststore`)) {
+    const standaloneBuildFiles = readdirSync3(
+      `${tmpDir}/.next/standalone/${prefix}.faststore`
+    );
+    await Promise.all(
+      standaloneBuildFiles.map(
+        (file) => moveSync2(
+          `${tmpDir}/.next/standalone/${prefix}.faststore/${file}`,
+          `${tmpDir}/.next/standalone/${file}`,
+          { overwrite: true }
+        )
+      )
+    );
+    removeSync2(`${tmpDir}/.next/standalone/${prefix}.faststore`);
+  }
+}
+async function copyResources(basePath) {
+  const { tmpDir, userDir } = withBasePath(basePath);
+  if (process.env.BUILD_CONTEXT === "vercel") {
+    const toDir = process.cwd();
+    const nextOutputDirectory = `${tmpDir}/.next`;
+    const expectedOutputDirectory = `${toDir}/.faststore/.next`;
+    if (nextOutputDirectory !== expectedOutputDirectory) {
+      await copyResource(nextOutputDirectory, expectedOutputDirectory);
+    }
+    await copyResource(`${tmpDir}/public`, `${toDir}/public`);
+  } else {
+    await copyResource(`${tmpDir}/.next`, `${userDir}/.next`);
+    await copyResource(
+      `${tmpDir}/lighthouserc.js`,
+      `${userDir}/lighthouserc.js`
+    );
+    await copyResource(`${tmpDir}/public`, `${userDir}/public`);
+  }
+}
+async function checkDeps(basePath) {
+  const packageJsonPath = `${basePath}/package.json`;
+  if (!existsSync6(packageJsonPath)) {
+    console.log(
+      `${chalk5.yellow(
+        "warning"
+      )} - package.json not found at ${packageJsonPath}`
+    );
+  }
+  try {
+    const mod = await import(pathToFileURL(packageJsonPath).href, {
+      with: { type: "json" }
+    });
+    const pkg = mod.default ?? mod;
+    const {
+      devDependencies = {},
+      dependencies = {},
+      peerDependencies = {}
+    } = pkg;
+    const allDeps = Object.assign(
+      {},
+      peerDependencies,
+      devDependencies,
+      dependencies
+    );
+    const invalidPackages = [];
+    Object.entries(allDeps).forEach(([pkg2, version]) => {
+      if (/^@faststore\/.+/i.test(pkg2) === false) return;
+      if (version && /^(http|https|git):.+/.test(version) === true) {
+        invalidPackages.push(pkg2);
+      }
+    });
+    return invalidPackages;
+  } catch (err) {
+    console.log(
+      `${chalk5.yellow("warning")} - unable to check @faststore dependencies: ${err}`
+    );
+    return [];
+  }
+}
+
+// src/commands/cms-sync.ts
+import { Args as Args2, Command as Command2, Flags as Flags2 } from "@oclif/core";
+import { spawn } from "child_process";
+
+// src/utils/hcms.ts
+import path7 from "path";
+import chalk6 from "chalk";
+import { confirm } from "@inquirer/prompts";
+import fsExtra5 from "fs-extra";
+var { readFileSync: readFileSync2, existsSync: existsSync7, writeFileSync: writeFileSync3, mkdirSync: mkdirSync2 } = fsExtra5;
+function splitCustomDefinitions(coreDefinitions, customDefinitions, primaryIdentifier) {
+  const coreDefinitionIdentifiers = new Set(
+    coreDefinitions.map((definition) => definition[primaryIdentifier] ?? "")
+  );
+  const duplicates = [];
+  const newDefinitions = [];
+  customDefinitions.forEach((definition) => {
+    if (!definition[primaryIdentifier]) {
+      console.error("Ignoring invalid definition:", definition);
+      return;
+    }
+    if (coreDefinitionIdentifiers.has(definition[primaryIdentifier])) {
+      duplicates.push(definition);
+      return;
+    }
+    newDefinitions.push(definition);
+  });
+  return { duplicates, newDefinitions };
+}
+function dedupeAndMergeDefinitions(coreDefinitions, duplicates, primaryIdentifier) {
+  const sortedCoreDefs = coreDefinitions.filter(
+    (definition) => Boolean(definition[primaryIdentifier])
+  );
+  sortedCoreDefs.sort(
+    (a, b) => a[primaryIdentifier] < b[primaryIdentifier] ? -1 : 1
+  );
+  const sortedDuplicates = duplicates.filter(
+    (definition) => Boolean(definition[primaryIdentifier])
+  );
+  sortedDuplicates.sort(
+    (a, b) => a[primaryIdentifier] < b[primaryIdentifier] ? -1 : 1
+  );
+  let duplicateIdx = 0;
+  const result = sortedCoreDefs.map((currentDefinition) => {
+    const isDuplicateMatch = currentDefinition[primaryIdentifier] === sortedDuplicates[duplicateIdx]?.[primaryIdentifier];
+    if (duplicateIdx < sortedDuplicates.length && isDuplicateMatch) {
+      return sortedDuplicates[duplicateIdx++];
+    }
+    return currentDefinition;
+  });
+  return result;
+}
+async function confirmUserChoice(duplicates, fileName) {
+  const goAhead = await confirm({
+    message: `You are about to override default ${fileName.split(".")[0]}:
+
+${duplicates.map((definition) => definition.id || definition.name).join("\n")}
+
+Are you sure? [yes/no]`
+  });
+  if (!goAhead) {
+    throw new Error("cms-sync cancelled by user.");
+  }
+  return;
+}
+async function mergeCMSFile(fileName, basePath) {
+  const {
+    coreCMSDir,
+    userCMSDir,
+    tmpCMSDir,
+    getPackagePath,
+    userStoreConfigFile
+  } = withBasePath(basePath);
+  const { default: userStoreConfig } = await import(path7.resolve(userStoreConfigFile));
+  const cmsProjectName = userStoreConfig.contentSource?.project ?? "faststore";
+  const coreFilePath = path7.join(coreCMSDir, fileName);
+  const customFilePath = path7.join(userCMSDir, fileName);
+  const coreFile = readFileSync2(coreFilePath, "utf8");
+  const coreDefinitions = JSON.parse(coreFile);
+  const primaryIdentifierForDefinitions = fileName === "content-types.json" ? "id" : "name";
+  let output = coreDefinitions;
+  const plugins = await getPluginsList(basePath);
+  const pluginCMSFilePaths = plugins.map(
+    (plugin) => getPackagePath(getPluginName(plugin), "cms", "faststore", fileName)
+  );
+  const customizations = [...pluginCMSFilePaths, customFilePath].filter(
+    (pluginCMSFilePath) => existsSync7(pluginCMSFilePath)
+  );
+  for (const newFilePath of customizations) {
+    const customFile = readFileSync2(newFilePath, "utf8");
+    try {
+      const customDefinitions = JSON.parse(customFile);
+      const { duplicates, newDefinitions } = splitCustomDefinitions(
+        output,
+        customDefinitions,
+        primaryIdentifierForDefinitions
+      );
+      if (duplicates.length) {
+        if (newFilePath === customFilePath) {
+          await confirmUserChoice(duplicates, fileName);
+        }
+        output = [
+          ...dedupeAndMergeDefinitions(
+            output,
+            duplicates,
+            primaryIdentifierForDefinitions
+          ),
+          ...newDefinitions
+        ];
+      } else {
+        output = [...output, ...newDefinitions];
+      }
+    } catch (err) {
+      if (err instanceof SyntaxError) {
+        console.info(
+          `${chalk6.red(
+            "error"
+          )} - ${fileName} is a malformed JSON file, ignoring its contents.`
+        );
+      } else {
+        throw err;
+      }
+    }
+  }
+  try {
+    if (!existsSync7(tmpCMSDir(cmsProjectName))) {
+      mkdirSync2(tmpCMSDir(cmsProjectName));
+    }
+    writeFileSync3(
+      path7.join(tmpCMSDir(cmsProjectName), fileName),
+      JSON.stringify(output)
+    );
+    console.log(
+      `${chalk6.green("success")} - CMS file ${chalk6.dim(fileName)} created`
+    );
+  } catch (err) {
+    console.error(`${chalk6.red("error")} - ${err}`);
+  }
+}
+async function mergeCMSFiles(basePath) {
+  try {
+    await mergeCMSFile("content-types.json", basePath);
+    await mergeCMSFile("sections.json", basePath);
+  } catch (err) {
+    console.error(`${chalk6.red("error")} - ${err}`);
+  }
+}
+
+// src/commands/cms-sync.ts
+import path8 from "path";
+var CmsSync = class _CmsSync extends Command2 {
+  static flags = {
+    ["dry-run"]: Flags2.boolean({ char: "d" })
+  };
+  static args = {
+    path: Args2.string({
+      name: "path",
+      description: "The path where the FastStore being synched with the CMS is. Defaults to cwd."
+    })
+  };
+  async run() {
+    const { flags, args } = await this.parse(_CmsSync);
+    const basePath = getBasePath(args.path);
+    const { tmpDir, userStoreConfigFile } = withBasePath(basePath);
+    const { default: userStoreConfig } = await import(path8.resolve(userStoreConfigFile));
+    const cmsProjectName = userStoreConfig.contentSource?.project ?? "faststore";
+    await generate({ setup: true, basePath });
+    await mergeCMSFiles(basePath);
+    if (flags["dry-run"]) {
+      return;
+    }
+    return spawn(`vtex cms sync ${cmsProjectName}`, {
+      shell: true,
+      cwd: tmpDir,
+      stdio: "inherit"
+    });
+  }
+};
+
+// src/commands/create.ts
+import fs2 from "fs";
+import degit from "degit";
+import { Args as Args3, Command as Command3 } from "@oclif/core";
+import { confirm as confirm2 } from "@inquirer/prompts";
+var Create = class _Create extends Command3 {
+  static args = {
+    path: Args3.string({
+      name: "path",
+      description: "The path where the Discovery folder will be created. Defaults to ./discovery."
+    })
+  };
+  static description = "Creates a discovery folder based on the starter.store template.";
+  static examples = ["$ yarn faststore create discovery"];
+  async run() {
+    const { args } = await this.parse(_Create);
+    const discoveryPath = args.path ?? "./discovery";
+    const discoveryFolderExists = fs2.existsSync(discoveryPath);
+    if (discoveryFolderExists) {
+      const confirmOverride = await confirm2({
+        message: `It looks like you already have a discovery folder named "${discoveryPath}" in your store. Do you want to override it?`
+      });
+      if (!confirmOverride)
+        return this.log("\u{1F6D1} Interrupted initializing discovery");
+    }
+    const discoveryEmitter = degit("vtex-sites/starter.store", {
+      force: true
+    });
+    this.log("Pulling starter.store template...");
+    discoveryEmitter.clone(discoveryPath).then(() => {
+      this.log(
+        `Discovery created successfully! You can find it at ${discoveryPath}`
+      );
+    });
+  }
+};
+
+// src/commands/dev.ts
+import { Args as Args4, Command as Command4, Flags as Flags3 } from "@oclif/core";
+import chalk7 from "chalk";
+import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
+import chokidar from "chokidar";
+import dotenv from "dotenv";
+import { cpSync, existsSync as existsSync8, readFileSync as readFileSync3 } from "fs";
+import path9 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var stabilityThreshold = process.platform === "darwin" ? 100 : 200;
+var defaultPatterns = ["*/**", "**"];
+var defaultIgnored = [
+  ".DS_Store",
+  "README.md",
+  ".gitignore",
+  "package.json",
+  ".git/**",
+  ".faststore/**",
+  "**/.faststore/**"
+];
+var defaultNodeModulesIgnored = ["node_modules/**", "**/node_modules/**"];
+var defaultNodeModulesIgnoredExceptVtexPackages = [
+  "**/node_modules/!(@vtex)/**"
+];
+var devAbortController = new AbortController();
+async function storeDev(rootDir, tmpDir, coreDir, port) {
+  let envVars = {};
+  const vtexEnvPath = path9.join(rootDir, "vtex.env");
+  if (existsSync8(vtexEnvPath)) {
+    try {
+      envVars = dotenv.parse(readFileSync3(vtexEnvPath));
+    } catch (err) {
+      logger.log(
+        `${chalk7.yellow("warn")} - Error parsing vtex.env file: ${err}`
+      );
+    }
+  }
+  const packageManager = await getPreferredPackageManager();
+  runCommandSync({
+    cmd: `${packageManager} predev`,
+    errorMessage: "GraphQL was not optimized and TS files were not updated. Changes in the GraphQL layer did not take effect",
+    throws: "error",
+    cwd: tmpDir
+  });
+  const { success } = copyGenerated(
+    path9.join(tmpDir, "@generated"),
+    path9.join(coreDir, "@generated")
+  );
+  if (!success) {
+    logger.log(
+      `${chalk7.yellow("warn")} - Failed to copy @generated schema back to node_modules, autocomplete and DX might be impacted.`
+    );
+    logger.log(
+      `Attempted to copy from ${path9.join(tmpDir, "@generated")} to ${path9.join(coreDir, "@generated")}`
+    );
+  }
+  const devProcess = spawn2(`${packageManager} dev-only --port ${port}`, {
+    shell: true,
+    cwd: tmpDir,
+    signal: devAbortController.signal,
+    stdio: ["inherit", "pipe", "inherit"],
+    env: {
+      ...process.env,
+      ...envVars
+    }
+  });
+  let nextStdout = "";
+  devProcess.stdout.on("data", (chunk) => {
+    nextStdout += chunk;
+    const lines = nextStdout.split("\n");
+    while (lines.length > 1) {
+      const line = lines.shift();
+      console.log("[DISCOVERY] ", line);
+    }
+    nextStdout = lines.shift() || "";
+  });
+  devProcess.stdout.on("end", () => {
+    console.log("[DISCOVERY] ", nextStdout);
+  });
+  devProcess.on("close", () => {
+    devAbortController.abort();
+  });
+}
+function copyGenerated(from, to) {
+  try {
+    cpSync(from, to, { recursive: true, force: true, dereference: true });
+    return { success: true };
+  } catch (err) {
+    return { success: false };
+  }
+}
+var Dev = class _Dev extends Command4 {
+  static args = {
+    path: Args4.string({
+      name: "path",
+      description: "The path where the FastStore being run is. Defaults to cwd."
+    }),
+    account: Args4.string({
+      name: "account",
+      description: "The account for which the Discovery is running. Currently noop."
+    }),
+    port: Args4.string({
+      name: "port",
+      description: "The port where FastStore should run. Defaults to 3000."
+    })
+  };
+  static flags = {
+    "watch-plugins": Flags3.boolean({
+      description: "Enable watching for plugin changes",
+      default: false
+    })
+  };
+  async run() {
+    const { args, flags } = await this.parse(_Dev);
+    const basePath = getBasePath(args.path);
+    const port = args.port ?? "3000";
+    const watchPlugins = flags["watch-plugins"];
+    const { getRoot, tmpDir, coreDir } = withBasePath(basePath);
+    checkDeprecatedSecretFiles(basePath);
+    const queueChange = () => {
+      generate({ basePath });
+    };
+    const watcher = chokidar.watch([...defaultPatterns], {
+      atomic: stabilityThreshold,
+      awaitWriteFinish: {
+        stabilityThreshold
+      },
+      cwd: getRoot(),
+      ignoreInitial: true,
+      ignored: [
+        ...defaultIgnored,
+        ...watchPlugins ? defaultNodeModulesIgnoredExceptVtexPackages : defaultNodeModulesIgnored
+      ],
+      persistent: true,
+      usePolling: process.platform === "win32"
+    });
+    devAbortController.signal.addEventListener("abort", () => {
+      watcher.close();
+    });
+    await generate({ setup: true, basePath });
+    const cliPath = fileURLToPath3(
+      import.meta.resolve("@faststore/cli/runner", import.meta.url)
+    );
+    spawnSync3("node", [cliPath, "generate-types", tmpDir], {
+      stdio: "inherit"
+    });
+    spawnSync3("node", [cliPath, "cache-graphql", basePath], {
+      stdio: "inherit"
+    });
+    spawnSync3("node", [cliPath, "generate-i18n", basePath], {
+      stdio: "inherit"
+    });
+    const config = await getDiscoveryConfig(basePath);
+    const localizationEnabled = config?.localization?.enabled === true;
+    toggleProxyByLocalizationFlag(basePath, localizationEnabled);
+    storeDev(getRoot(), tmpDir, coreDir, port);
+    return await new Promise((resolve, reject) => {
+      watcher.on("add", () => queueChange(
+        /*file, false*/
+      )).on("change", () => queueChange(
+        /*file, false*/
+      )).on("unlink", () => queueChange(
+        /*file, true*/
+      )).on("error", () => {
+        devAbortController.abort();
+        reject();
+      }).on("ready", resolve);
+    });
+  }
+};
+
+// src/commands/generate.ts
+import { Args as Args5, Command as Command5 } from "@oclif/core";
+import chalk8 from "chalk";
+
+// src/utils/file.ts
+import fs3 from "fs";
+import path10 from "path";
+function saveFile(fileLocation) {
+  fs3.mkdirSync(path10.dirname(fileLocation), { recursive: true });
+  return (content) => {
+    fs3.writeFileSync(fileLocation, content);
+  };
+}
+
+// src/utils/generate-types.ts
+import { GraphqlVtexSchema } from "@faststore/api";
+import {
+  generate as codegenGenerate
+} from "@graphql-codegen/cli";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { buildASTSchema, Kind, parse } from "graphql";
+import fs4, { existsSync as existsSync9 } from "fs";
+import path11 from "path";
+var schemaFileName = "schema.graphql";
+async function genTsTypes(at) {
+  await generateSchemaFile(at);
+  generateSchemaTSTypes(at);
+}
+function generateSchemaTSTypes(root) {
+  let finalRootPath = path11.resolve(root);
+  if (existsSync9(path11.resolve(root, ".faststore"))) {
+    finalRootPath = path11.resolve(root, ".faststore");
+  }
+  const documents = [`${finalRootPath}/src/**/*.{ts,tsx}`];
+  const config = {
+    documents,
+    overwrite: true,
+    errorsOnly: false,
+    debug: false,
+    verbose: true,
+    schema: path11.resolve(finalRootPath, "@generated", schemaFileName),
+    generates: {
+      [`${finalRootPath}/@generated/`]: {
+        preset: "client",
+        config: {
+          /** Not all of these properties are supported by the preset, but it reflects our previous config when we used typescript plugins directly */
+          preResolveTypes: true,
+          avoidOptionals: true,
+          enumsAsTypes: true,
+          skipTypeNameForRoot: true,
+          skipTypename: true,
+          allowEnumStringTypes: false,
+          flattenGeneratedTypes: true,
+          namingConvention: "change-case-all#pascalCase",
+          exportFragmentSpreadSubTypes: true,
+          /** Removes useless AST definitions from documents */
+          documentMode: "string"
+        },
+        presetConfig: {
+          // Disabled fragment masking - it wasn't being used by us. This can be reviewed in the future
+          fragmentMasking: false,
+          // Recognizes the gql(`query { ... }`) calls and generates the types for them
+          gqlTagName: "gql",
+          onExecutableDocumentNode: (document) => ({
+            // This makes sure that the operation name is always present in the __meta__ field of each query
+            // This helps us to identify the query in the persisted documents and to debug errors in the client
+            operationName: getOperationName(document)
+          }),
+          persistedDocuments: {
+            // Keeps document simple, including only necessary properties as '__meta__' and its properties
+            mode: "replaceDocumentWithHash",
+            // replaces operation['__meta__']['hash'] with operation['__meta__']['operationHash']
+            hashPropertyName: "operationHash"
+          }
+        }
+      }
+    }
+  };
+  return codegenGenerate(config, true);
+}
+function getOperationName(document) {
+  for (const definition of document.definitions) {
+    if (definition.kind === Kind.OPERATION_DEFINITION && typeof definition.name?.value === "string") {
+      return definition.name.value;
+    }
+  }
+  return "UnknownOperation";
+}
+async function generateSchemaFile(rootPath) {
+  const faststoreSchema = printSchemaWithDirectives(GraphqlVtexSchema());
+  const getMergedSchema = async () => {
+    const root = path11.join(
+      rootPath.endsWith(".faststore") ? [rootPath, ".."].join("/") : rootPath
+    );
+    const customizations = [
+      ...await getTypeDefsFromFolder(root, "vtex"),
+      ...await getTypeDefsFromFolder(root, "thirdParty")
+    ];
+    try {
+      const mergedTypeDefs = mergeTypeDefs(
+        [faststoreSchema, ...customizations].filter(Boolean)
+      );
+      return buildASTSchema(mergedTypeDefs);
+    } catch (e) {
+      console.error(
+        'An error occurred while attempting to merge the GraphQL Schema Extensions. Check the custom typeDefs and resolvers located in the "customizations/graphql/" directory. The changes since the last successful schema merge will be ignored.'
+      );
+      throw e;
+    }
+  };
+  let pathToSave = path11.resolve(rootPath, "@generated", schemaFileName);
+  if (existsSync9(path11.resolve(rootPath, ".faststore"))) {
+    pathToSave = path11.resolve(
+      rootPath,
+      ".faststore",
+      "@generated",
+      schemaFileName
+    );
+  }
+  const saveSchemaFile = saveFile(pathToSave);
+  const finalSchema = printSchemaWithDirectives(await getMergedSchema());
+  saveSchemaFile(finalSchema);
+}
+async function getTypeDefsFromFolder(root, customPath) {
+  const globby = await import("globby");
+  const basePath = [root, "src", "graphql"];
+  const pathArray = Array.isArray(customPath) ? customPath : [customPath];
+  return (globby.default ?? globby).globbySync(path11.join(...[...basePath, ...pathArray]), {
+    expandDirectories: {
+      extensions: ["graphql"]
+    }
+  }).map(
+    (typeDef) => parse(fs4.readFileSync(typeDef, { encoding: "utf-8" }))
+  );
+}
+
+// src/commands/generate.ts
+var Generate = class _Generate extends Command5 {
+  static flags = {};
+  static args = {
+    path: Args5.string({
+      name: "path",
+      hidden: true,
+      description: "The path where the FastStore being built is. Defaults to cwd."
+    })
+  };
+  async run() {
+    const { args } = await this.parse(_Generate);
+    const basePath = getBasePath(args.path);
+    const { tmpDir } = withBasePath(basePath);
+    await generate({ setup: true, basePath });
+    genTsTypes(args.path ?? tmpDir);
+    logger.log(
+      `${chalk8.green(
+        "success"
+      )} - GraphQL schema, types, and optimizations successfully generated \u{1F389}`
+    );
+  }
+};
+
+// src/commands/prepare.ts
+import { Args as Args6, Command as Command6 } from "@oclif/core";
+import fs5 from "fs";
+import path12 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var Prepare = class _Prepare extends Command6 {
+  static args = {
+    path: Args6.string({
+      name: "path",
+      description: "The path where the FastStore being run is. Defaults to cwd."
+    })
+  };
+  async run() {
+    const { args } = await this.parse(_Prepare);
+    const basePath = getBasePath(args.path);
+    const clientPublicDir = path12.join(basePath, "public/");
+    const corePublicDir = path12.resolve(
+      fileURLToPath4(
+        path12.dirname(import.meta.resolve("@faststore/core", import.meta.url))
+      ),
+      "public"
+    );
+    if (!corePublicDir) {
+      throw Error("Please install @faststore/core package");
+    }
+    copyFolder(corePublicDir, clientPublicDir);
+  }
+};
+function copyFolder(sourceDir, targetDir) {
+  if (!fs5.existsSync(targetDir)) {
+    fs5.mkdirSync(targetDir, { recursive: true });
+  }
+  const files = fs5.readdirSync(sourceDir);
+  for (const file of files) {
+    const sourcePath = path12.join(sourceDir, file);
+    const targetPath = path12.join(targetDir, file);
+    const stat = fs5.statSync(sourcePath);
+    if (stat.isFile()) {
+      fs5.copyFileSync(sourcePath, targetPath);
+      console.log(`Copied file: ${sourcePath} -> ${targetPath}`);
+    } else if (stat.isDirectory()) {
+      copyFolder(sourcePath, targetPath);
+    }
+  }
+}
+
+// src/commands/start.ts
+import { Args as Args7, Command as Command7 } from "@oclif/core";
+import { spawn as spawn3, spawnSync as spawnSync4 } from "child_process";
+import fsExtra6 from "fs-extra";
+import path13 from "path";
+var { existsSync: existsSync10 } = fsExtra6;
+var Start = class _Start extends Command7 {
+  static args = {
+    account: Args7.string({
+      description: "The account for which the Discovery is running. Currently noop."
+    }),
+    path: Args7.string({
+      description: "The path where the FastStore being run is. Defaults to cwd."
+    }),
+    port: Args7.string({
+      description: "The port where FastStore should run. Defaults to 3000."
+    })
+  };
+  async run() {
+    const { args } = await this.parse(_Start);
+    const basePath = getBasePath(args.path);
+    const port = args.port ?? 3e3;
+    const { getRoot, tmpDir } = withBasePath(basePath);
+    const packageManager = await getPreferredPackageManager();
+    if (!existsSync10(path13.join(getRoot(), ".next"))) {
+      spawnSync4(`${packageManager} faststore build`, {
+        shell: true,
+        stdio: "inherit"
+      });
+    }
+    return spawn3(
+      packageManager,
+      ["next", "start", tmpDir, "-p", String(port)],
+      {
+        stdio: "inherit"
+      }
+    );
+  }
+};
+
+// src/commands/test.ts
+import { Args as Args8, Command as Command8 } from "@oclif/core";
+import { spawn as spawn4 } from "child_process";
+import chokidar2 from "chokidar";
+var stabilityThreshold2 = process.platform === "darwin" ? 100 : 200;
+var defaultPatterns2 = ["*/**", "**"];
+var defaultIgnored2 = [
+  ".DS_Store",
+  "README.md",
+  ".gitignore",
+  "package.json",
+  "node_modules/**",
+  "**/node_modules/**",
+  ".git/**",
+  ".faststore/**",
+  "**/.faststore/**"
+];
+var testAbortController = new AbortController();
+async function storeTest(tmpDir) {
+  const packageManager = await getPreferredPackageManager();
+  const testProcess = spawn4(`${packageManager} run test:e2e`, {
+    shell: true,
+    cwd: tmpDir,
+    signal: testAbortController.signal,
+    stdio: "inherit"
+  });
+  testProcess.on("close", () => {
+    testAbortController.abort();
+  });
+}
+var Test = class _Test extends Command8 {
+  static args = {
+    path: Args8.string({
+      name: "path",
+      description: "The path where the FastStore being tested is. Defaults to cwd."
+    })
+  };
+  async run() {
+    const { args } = await this.parse(_Test);
+    const basePath = getBasePath(args.path);
+    const { getRoot, tmpDir } = withBasePath(basePath);
+    const watcher = chokidar2.watch([...defaultPatterns2], {
+      atomic: stabilityThreshold2,
+      awaitWriteFinish: {
+        stabilityThreshold: stabilityThreshold2
+      },
+      cwd: getRoot(),
+      ignoreInitial: true,
+      ignored: defaultIgnored2,
+      persistent: true,
+      usePolling: process.platform === "win32"
+    });
+    testAbortController.signal.addEventListener("abort", () => {
+      watcher.close();
+    });
+    await generate({ setup: true, basePath });
+    storeTest(tmpDir);
+    return await new Promise((resolve, reject) => {
+      watcher.on("error", () => {
+        testAbortController.abort();
+        reject();
+      }).on("ready", resolve);
+    });
+  }
+};
+
+// src/commands/generate-types.ts
+import path14 from "path";
+import { Args as Args9, Command as Command9 } from "@oclif/core";
+import chalk9 from "chalk";
+var Generate2 = class _Generate extends Command9 {
+  static hidden = true;
+  static flags = {};
+  static args = {
+    path: Args9.string({
+      name: "path",
+      required: true,
+      description: "The path where the FastStore being built is. Defaults to cwd."
+    })
+  };
+  async run() {
+    const { args } = await this.parse(_Generate);
+    await genTsTypes(
+      path14.isAbsolute(args.path) ? args.path : path14.resolve(process.env.PWD ?? process.cwd(), args.path)
+    );
+    logger.log(
+      `${chalk9.green(
+        "success"
+      )} - GraphQL schema, types, and optimizations successfully generated \u{1F389}`
+    );
+  }
+};
+
+// src/commands/cache-graphql.ts
+import { Args as Args10, Command as Command10, Flags as Flags4 } from "@oclif/core";
+import chalk10 from "chalk";
+import graphql from "graphql";
+import path15 from "path";
+import fsExtra7 from "fs-extra";
+var { Kind: Kind2, OperationTypeNode, parse: parseGraphql } = graphql;
+var persistedDocumentsName = "persisted-documents.json";
+var configFileName2 = "discovery.config.default.js";
+var cachedOperationsFileName = "cached-operations.json";
+var CacheGraphql = class _CacheGraphql extends Command10 {
+  static flags = {
+    queries: Flags4.string({
+      name: "queries",
+      description: "The path to locate persisted-document file."
+    }),
+    config: Flags4.string({
+      name: "config",
+      description: "The path where the discovery.config is located"
+    })
+  };
+  static args = {
+    store: Args10.string({
+      name: "store",
+      description: "The path where the FastStore being built is or the persisted-document path. Defaults to cwd."
+    })
+  };
+  async run() {
+    const { args, flags } = await this.parse(_CacheGraphql);
+    const rootPath = getBasePath();
+    const argPath = args?.store && path15.resolve(rootPath, args.store) || rootPath;
+    const { tmpDir } = withBasePath(argPath);
+    const configPath = this.getConfigFile(flags.config && path15.resolve(argPath, flags.config)) || this.getConfigFile(tmpDir) || this.getConfigFile(argPath);
+    const persistedDocumentsPath = this.getPersistedDocument(
+      flags?.queries && path15.resolve(argPath, flags?.queries) || argPath
+    ) || this.getPersistedDocument(tmpDir);
+    if (!configPath) {
+      return this.errorFileNotFound(
+        configFileName2,
+        `
+    ${tmpDir}
+    ${argPath}`
+      );
+    }
+    if (!persistedDocumentsPath) {
+      return this.errorFileNotFound(
+        persistedDocumentsName,
+        flags?.queries ?? argPath
+      );
+    }
+    const cachedOperationsPath = path15.join(
+      path15.dirname(persistedDocumentsPath),
+      cachedOperationsFileName
+    );
+    const saveCachedOperationsFile = saveFile(cachedOperationsPath);
+    if (fsExtra7.pathExistsSync(tmpDir))
+      logger.info(`${chalk10.blue("[Info]")} - .faststore Path at: ${tmpDir}`);
+    logger.info(`${chalk10.blue("[Info]")} - Config file location: ${configPath}`);
+    logger.info(
+      `${chalk10.blue("[Info]")} - Persisted documents at: ${persistedDocumentsPath}`
+    );
+    logger.info(
+      `${chalk10.blue("[Info]")} - Cached operations output: ${cachedOperationsPath}`
+    );
+    const { default: persistedDocuments } = await import(persistedDocumentsPath, { with: { type: "json" } });
+    const cachedQueries = getQueries(persistedDocuments);
+    saveCachedOperationsFile(
+      `${JSON.stringify(cachedQueries ?? [], null, 2)}
+`
+    );
+    logger.info(
+      `${chalk10.green("[Success]")} - GraphQL queries cached with success: \u{1F389}
+      Queries: ${cachedQueries.join(", ")}`
+    );
+  }
+  getPersistedDocument(rootPath) {
+    return this.getFile(persistedDocumentsName, [
+      "@generated",
+      persistedDocumentsName
+    ])(rootPath);
+  }
+  getConfigFile(rootPath) {
+    return this.getFile(configFileName2, [configFileName2])(rootPath);
+  }
+  getFile(fileName, pathFromRoot) {
+    return (rootPath) => {
+      switch (true) {
+        case !rootPath:
+          return;
+        case (rootPath?.endsWith(fileName) && fsExtra7.existsSync(rootPath)):
+          return rootPath;
+        case fsExtra7.existsSync(path15.join(rootPath ?? "", fileName)):
+          return path15.join(rootPath, fileName);
+        default:
+          if (!pathFromRoot) return;
+          const filePath = path15.join(
+            rootPath,
+            ...Array.isArray(pathFromRoot) ? pathFromRoot : [pathFromRoot]
+          );
+          if (fsExtra7.existsSync(filePath)) {
+            return filePath;
+          }
+          return;
+      }
+    };
+  }
+  errorFileNotFound(fileName, rootDir) {
+    logger.error(
+      `${chalk10.red("[Error]")} - Couldn't find ${fileName} at ${rootDir}`
+    );
+    process.exit(1);
+  }
+};
+var getQueries = (persistedDocuments) => {
+  const operationNames = [];
+  for (const operation of Object.values(persistedDocuments)) {
+    let currentNames = [];
+    const operationAST = parseGraphql(operation);
+    const hasMutationDefinition = operationAST.definitions.some(
+      (def) => def.kind === Kind2.OPERATION_DEFINITION && def.operation === OperationTypeNode.MUTATION
+    );
+    if (hasMutationDefinition) continue;
+    operationAST.definitions.forEach((definition) => {
+      if (definition.kind === Kind2.OPERATION_DEFINITION && definition.operation === OperationTypeNode.QUERY && definition.name?.kind === Kind2.NAME && !!definition.name?.value) {
+        currentNames.push(definition.name.value);
+        return;
+      }
+    });
+    if (currentNames.length) {
+      operationNames.push(...currentNames);
+      currentNames = [];
+    }
+  }
+  return operationNames;
+};
+
+// src/commands/generate-i18n.ts
+import { Args as Args11, Command as Command11, Flags as Flags5 } from "@oclif/core";
+import { FastStoreSDK } from "@vtex/faststore-sdk";
+import chalk11 from "chalk";
+import dotenv2 from "dotenv";
+import fsExtra8 from "fs-extra";
+import { existsSync as existsSync11 } from "fs";
+import path16 from "path";
+import { format } from "prettier";
+var configFileName3 = "discovery.config.default.js";
+var GenerateI18n = class _GenerateI18n extends Command11 {
+  static hidden = true;
+  static flags = {
+    config: Flags5.string({
+      name: "config",
+      description: "The path where the discovery.config is located"
+    })
+  };
+  static args = {
+    path: Args11.string({
+      name: "path",
+      description: "The path where the FastStore being built is. Defaults to cwd."
+    })
+  };
+  getConfigFile(rootPath) {
+    return this.getFile(configFileName3, [configFileName3])(rootPath);
+  }
+  getFile(fileName, pathFromRoot) {
+    return (rootPath) => {
+      switch (true) {
+        case !rootPath:
+          return;
+        case (rootPath?.endsWith(fileName) && fsExtra8.existsSync(rootPath)):
+          return rootPath;
+        case fsExtra8.existsSync(path16.join(rootPath ?? "", fileName)):
+          return path16.join(rootPath, fileName);
+        default:
+          if (!pathFromRoot) return;
+          const filePath = path16.join(
+            rootPath,
+            ...Array.isArray(pathFromRoot) ? pathFromRoot : [pathFromRoot]
+          );
+          if (fsExtra8.existsSync(filePath)) {
+            return filePath;
+          }
+          return;
+      }
+    };
+  }
+  errorFileNotFound(fileName, rootDir) {
+    logger.error(
+      `${chalk11.red("[Error]")} - Couldn't find ${fileName} at ${rootDir}`
+    );
+    process.exit(1);
+  }
+  async run() {
+    const { args, flags } = await this.parse(_GenerateI18n);
+    const rootPath = getBasePath();
+    const argPath = args?.path && path16.resolve(rootPath, args.path) || rootPath;
+    const localizationEnabled = await checkAndValidateLocalization(argPath);
+    if (!localizationEnabled) {
+      return;
+    }
+    const vtexEnvPath = path16.join(argPath, "vtex.env");
+    if (existsSync11(vtexEnvPath)) {
+      dotenv2.config({ path: vtexEnvPath });
+    }
+    const { VTEX_ACCOUNT, FS_DISCOVERY_APP_KEY, FS_DISCOVERY_APP_TOKEN } = process.env;
+    const hasCredentials = VTEX_ACCOUNT && FS_DISCOVERY_APP_KEY && FS_DISCOVERY_APP_TOKEN;
+    if (!hasCredentials) {
+      logger.error(`${chalk11.red("[Error]")} - Missing VTEX credentials.
+
+      ${chalk11.cyan("Required Action:")}
+
+      Check your FastStore WebOps Settings page - to work in production, it should contain the following variables: ${chalk11.cyan("VTEX_ACCOUNT")}, ${chalk11.cyan("FS_DISCOVERY_APP_KEY")}, ${chalk11.cyan("FS_DISCOVERY_APP_TOKEN")}.
+
+      If running locally, please check your ${chalk11.bold("vtex.env")} file, it should also contain those variables.
+      `);
+      process.exit(1);
+    }
+    const { tmpDir } = withBasePath(argPath);
+    const configPath = this.getConfigFile(flags.config && path16.resolve(argPath, flags.config)) || this.getConfigFile(tmpDir) || this.getConfigFile(argPath);
+    if (!configPath) {
+      return this.errorFileNotFound(
+        configFileName3,
+        `
+    ${tmpDir}
+    ${argPath}`
+      );
+    }
+    const saveConfigFile = saveFile(configPath);
+    if (fsExtra8.pathExistsSync(tmpDir))
+      logger.info(`${chalk11.blue("[Info]")} - .faststore Path at: ${tmpDir}`);
+    logger.info(`${chalk11.blue("[Info]")} - Config file location: ${configPath}`);
+    const discoveryConfig = await import(configPath);
+    const faststore = new FastStoreSDK({
+      account: VTEX_ACCOUNT,
+      appKey: FS_DISCOVERY_APP_KEY,
+      appToken: FS_DISCOVERY_APP_TOKEN
+    });
+    const settings = await faststore.locales();
+    const currentConfig = discoveryConfig?.default ?? discoveryConfig;
+    saveConfigFile(
+      await format(
+        `module.exports = ${JSON.stringify(
+          {
+            ...currentConfig,
+            localization: {
+              ...currentConfig?.localization ?? {},
+              ...settings
+            }
+          },
+          void 0,
+          2
+        )}`,
+        {
+          parser: "typescript",
+          quoteProps: "as-needed"
+        }
+      )
+    );
+    logger.info(
+      `${chalk11.green("success")} - i18n configuration successfully generated \u{1F389}`
+    );
+  }
+};
+
+// src/index.ts
+var commands = {
+  create: Create,
+  prepare: Prepare,
+  dev: Dev,
+  build: Build,
+  serve: Start,
+  "cms-sync": CmsSync,
+  test: Test,
+  generate: Generate,
+  "generate-types": Generate2,
+  "cache-graphql": CacheGraphql,
+  "generate-i18n": GenerateI18n
+};
+export {
+  commands,
+  run
 };
 //# sourceMappingURL=index.js.map