@shopify/cli-hydrogen 5.0.1 → 5.1.0

package/dist/commands/hydrogen/link.test.js

@@ -1,137 +1,171 @@
 import { vi, describe, beforeEach, afterEach, it, expect } from 'vitest';
 import { mockAndCaptureOutput } from '@shopify/cli-kit/node/testing/output';
-import { renderSelectPrompt, renderConfirmationPrompt } from '@shopify/cli-kit/node/ui';
-import { adminRequest } from '../../lib/graphql.js';
+import { renderSelectPrompt, renderTextPrompt, renderConfirmationPrompt } from '@shopify/cli-kit/node/ui';
+import { login } from '../../lib/auth.js';
 import { getStorefronts } from '../../lib/graphql/admin/link-storefront.js';
-import { getConfig, setStorefront } from '../../lib/shopify-config.js';
-import { linkStorefront } from './link.js';
+import { runLink } from './link.js';
+import { createStorefront } from '../../lib/graphql/admin/create-storefront.js';
+import { waitForJob } from '../../lib/graphql/admin/fetch-job.js';
+import { setStorefront } from '../../lib/shopify-config.js';
 
-const SHOP = "my-shop";
-const ADMIN_SESSION = {
-  token: "abc123",
-  storeFqdn: SHOP
-};
 vi.mock("@shopify/cli-kit/node/ui", async () => {
   const original = await vi.importActual("@shopify/cli-kit/node/ui");
   return {
     ...original,
     renderConfirmationPrompt: vi.fn(),
-    renderSelectPrompt: vi.fn()
+    renderSelectPrompt: vi.fn(),
+    renderTextPrompt: vi.fn()
   };
 });
-vi.mock("../../lib/graphql.js");
+vi.mock("../../lib/auth.js");
 vi.mock("../../lib/shopify-config.js");
 vi.mock("../../lib/graphql/admin/link-storefront.js");
-vi.mock("../../lib/shop.js", () => ({
-  getHydrogenShop: () => SHOP
-}));
-vi.mock("../../lib/shell.js", () => ({
-  getCliCommand: () => "h2"
-}));
+vi.mock("../../lib/graphql/admin/create-storefront.js");
+vi.mock("../../lib/graphql/admin/fetch-job.js");
+vi.mock("../../lib/shell.js", () => ({ getCliCommand: () => "h2" }));
 describe("link", () => {
   const outputMock = mockAndCaptureOutput();
+  const ADMIN_SESSION = {
+    token: "abc123",
+    storeFqdn: "my-shop.myshopify.com"
+  };
+  const FULL_SHOPIFY_CONFIG = {
+    shop: "my-shop.myshopify.com",
+    shopName: "My Shop",
+    email: "email",
+    storefront: {
+      id: "gid://shopify/HydrogenStorefront/1",
+      title: "Hydrogen"
+    }
+  };
+  const UNLINKED_SHOPIFY_CONFIG = {
+    ...FULL_SHOPIFY_CONFIG,
+    storefront: void 0
+  };
   beforeEach(async () => {
-    vi.mocked(getStorefronts).mockResolvedValue({
-      adminSession: ADMIN_SESSION,
-      storefronts: [
-        {
-          id: "gid://shopify/HydrogenStorefront/1",
-          parsedId: "1",
-          title: "Hydrogen",
-          productionUrl: "https://example.com"
-        }
-      ]
+    vi.mocked(login).mockResolvedValue({
+      session: ADMIN_SESSION,
+      config: UNLINKED_SHOPIFY_CONFIG
     });
-    vi.mocked(getConfig).mockResolvedValue({});
+    vi.mocked(getStorefronts).mockResolvedValue([
+      {
+        ...FULL_SHOPIFY_CONFIG.storefront,
+        parsedId: "1",
+        productionUrl: "https://example.com"
+      }
+    ]);
+    vi.mocked(renderSelectPrompt).mockResolvedValue(FULL_SHOPIFY_CONFIG.shop);
   });
   afterEach(() => {
     vi.resetAllMocks();
     outputMock.clear();
   });
-  it("makes a GraphQL call to fetch the storefronts", async () => {
-    await linkStorefront({});
-    expect(getStorefronts).toHaveBeenCalledWith(SHOP);
+  it("fetches the storefronts", async () => {
+    await runLink({});
+    expect(getStorefronts).toHaveBeenCalledWith(ADMIN_SESSION);
   });
   it("renders a list of choices and forwards the selection to setStorefront", async () => {
     vi.mocked(renderSelectPrompt).mockResolvedValue(
-      "gid://shopify/HydrogenStorefront/1"
+      FULL_SHOPIFY_CONFIG.storefront.id
     );
-    await linkStorefront({ path: "my-path" });
+    await runLink({ path: "my-path" });
     expect(setStorefront).toHaveBeenCalledWith(
       "my-path",
-      expect.objectContaining({
-        id: "gid://shopify/HydrogenStorefront/1",
-        title: "Hydrogen"
-      })
+      expect.objectContaining(FULL_SHOPIFY_CONFIG.storefront)
     );
   });
-  it("renders a success message", async () => {
-    vi.mocked(renderSelectPrompt).mockResolvedValue(
-      "gid://shopify/HydrogenStorefront/1"
-    );
-    await linkStorefront({ path: "my-path" });
-    expect(outputMock.info()).toMatch(/Hydrogen is now linked/g);
-    expect(outputMock.info()).toMatch(
-      /Run `h2 dev` to start your local development server and start building/g
-    );
+  describe("when you want to link an existing Hydrogen storefront", () => {
+    beforeEach(async () => {
+      vi.mocked(renderSelectPrompt).mockResolvedValue(
+        "gid://shopify/HydrogenStorefront/1"
+      );
+    });
+    it("renders a list of choices and forwards the selection to setStorefront", async () => {
+      vi.mocked(renderSelectPrompt).mockResolvedValue(
+        FULL_SHOPIFY_CONFIG.storefront.id
+      );
+      await runLink({ path: "my-path" });
+      expect(setStorefront).toHaveBeenCalledWith(
+        "my-path",
+        expect.objectContaining(FULL_SHOPIFY_CONFIG.storefront)
+      );
+    });
+    it("renders a success message", async () => {
+      vi.mocked(renderSelectPrompt).mockResolvedValue(
+        FULL_SHOPIFY_CONFIG.storefront.id
+      );
+      await runLink({ path: "my-path" });
+      expect(outputMock.info()).toMatch(/is now linked/i);
+      expect(outputMock.info()).toMatch(/Run `h2 dev`/i);
+    });
   });
-  describe("when there are no Hydrogen storefronts", () => {
-    it("renders a message and returns early", async () => {
-      vi.mocked(getStorefronts).mockResolvedValue({
-        adminSession: ADMIN_SESSION,
-        storefronts: []
+  describe("when you want to link a new Hydrogen storefront", () => {
+    const expectedStorefrontName = "New Storefront";
+    const expectedJobId = "gid://shopify/Job/1";
+    beforeEach(async () => {
+      vi.mocked(renderSelectPrompt).mockResolvedValue(null);
+      vi.mocked(createStorefront).mockResolvedValue({
+        storefront: {
+          id: "gid://shopify/HydrogenStorefront/1",
+          title: expectedStorefrontName,
+          productionUrl: "https://example.com"
+        },
+        jobId: expectedJobId
       });
-      await linkStorefront({});
-      expect(outputMock.info()).toMatch(
-        /There are no Hydrogen storefronts on your Shop/g
+    });
+    it("chooses to create a new storefront given the directory path", async () => {
+      await runLink({ path: "my-path" });
+      expect(renderTextPrompt).toHaveBeenCalledWith({
+        message: expect.stringMatching(/name/i),
+        defaultValue: "My Path"
+      });
+    });
+    it("handles the successful creation of the storefront on Admin", async () => {
+      await runLink({});
+      expect(waitForJob).toHaveBeenCalledWith(ADMIN_SESSION, expectedJobId);
+      expect(outputMock.info()).toContain(
+        `${expectedStorefrontName} is now linked`
       );
-      expect(renderSelectPrompt).not.toHaveBeenCalled();
-      expect(setStorefront).not.toHaveBeenCalled();
     });
-  });
-  describe("when no storefront gets selected", () => {
-    it("does not call setStorefront", async () => {
-      vi.mocked(renderSelectPrompt).mockResolvedValue("");
-      await linkStorefront({});
-      expect(setStorefront).not.toHaveBeenCalled();
+    it("handles the job errors when creating the storefront on Admin", async () => {
+      vi.mocked(waitForJob).mockRejectedValue(void 0);
+      await expect(runLink({})).rejects.toThrow(Error);
     });
   });
   describe("when a linked storefront already exists", () => {
     beforeEach(() => {
-      vi.mocked(getConfig).mockResolvedValue({
-        storefront: {
-          id: "gid://shopify/HydrogenStorefront/2",
-          title: "Existing Link"
-        }
+      vi.mocked(login).mockResolvedValue({
+        session: ADMIN_SESSION,
+        config: FULL_SHOPIFY_CONFIG
       });
     });
     it("prompts the user to confirm", async () => {
       vi.mocked(renderConfirmationPrompt).mockResolvedValue(true);
-      await linkStorefront({});
+      await runLink({});
       expect(renderConfirmationPrompt).toHaveBeenCalledWith({
         message: expect.stringMatching(
-          /Do you want to link to a different Hydrogen storefront on Shopify\?/
+          /link to a different Hydrogen storefront/i
         )
       });
     });
     describe("and the user cancels", () => {
       it("returns early", async () => {
         vi.mocked(renderConfirmationPrompt).mockResolvedValue(false);
-        await linkStorefront({});
-        expect(adminRequest).not.toHaveBeenCalled();
+        await runLink({});
+        expect(getStorefronts).not.toHaveBeenCalled();
         expect(setStorefront).not.toHaveBeenCalled();
       });
     });
     describe("and the --force flag is provided", () => {
       it("does not prompt the user to confirm", async () => {
-        await linkStorefront({ force: true });
+        await runLink({ force: true });
         expect(renderConfirmationPrompt).not.toHaveBeenCalled();
       });
     });
   });
   describe("when the --storefront flag is provided", () => {
     it("does not prompt the user to make a selection", async () => {
-      await linkStorefront({ path: "my-path", storefront: "Hydrogen" });
+      await runLink({ path: "my-path", storefront: "Hydrogen" });
       expect(renderSelectPrompt).not.toHaveBeenCalled();
       expect(setStorefront).toHaveBeenCalledWith(
         "my-path",
@@ -144,7 +178,7 @@ describe("link", () => {
     describe("and there is no matching storefront", () => {
       it("renders a warning message and returns early", async () => {
         const outputMock2 = mockAndCaptureOutput();
-        await linkStorefront({ storefront: "Does not exist" });
+        await runLink({ storefront: "Does not exist" });
         expect(setStorefront).not.toHaveBeenCalled();
         expect(outputMock2.warn()).toMatch(/Couldn\'t find Does not exist/g);
       });

package/dist/commands/hydrogen/list.js

@@ -2,32 +2,33 @@ import Command from '@shopify/cli-kit/node/base-command';
 import { pluralize } from '@shopify/cli-kit/common/string';
 import colors from '@shopify/cli-kit/node/colors';
 import { outputNewline, outputInfo, outputContent } from '@shopify/cli-kit/node/output';
+import { renderInfo } from '@shopify/cli-kit/node/ui';
 import { commonFlags } from '../../lib/flags.js';
-import { getHydrogenShop } from '../../lib/shop.js';
-import { parseGid } from '../../lib/graphql.js';
+import { parseGid } from '../../lib/gid.js';
 import { getStorefrontsWithDeployment } from '../../lib/graphql/admin/list-storefronts.js';
-import { logMissingStorefronts } from '../../lib/missing-storefronts.js';
+import { newHydrogenStorefrontUrl } from '../../lib/admin-urls.js';
+import { login } from '../../lib/auth.js';
+import { getCliCommand } from '../../lib/shell.js';
 
 class List extends Command {
   static description = "Returns a list of Hydrogen storefronts available on a given shop.";
   static flags = {
-    path: commonFlags.path,
-    shop: commonFlags.shop
+    path: commonFlags.path
   };
   async run() {
     const { flags } = await this.parse(List);
-    await listStorefronts(flags);
+    await runList(flags);
   }
 }
-async function listStorefronts({ path, shop: flagShop }) {
-  const shop = await getHydrogenShop({ path, shop: flagShop });
-  const { storefronts, adminSession } = await getStorefrontsWithDeployment(shop);
+async function runList({ path: root = process.cwd() }) {
+  const { session } = await login(root);
+  const storefronts = await getStorefrontsWithDeployment(session);
   if (storefronts.length > 0) {
     outputNewline();
     outputInfo(
       pluralizedStorefronts({
         storefronts,
-        shop
+        shop: session.storeFqdn
       }).toString()
     );
     storefronts.forEach(
@@ -53,7 +54,16 @@ async function listStorefronts({ path, shop: flagShop }) {
       }
     );
   } else {
-    logMissingStorefronts(adminSession);
+    renderInfo({
+      headline: "Hydrogen storefronts",
+      body: "There are no Hydrogen storefronts on your Shop.",
+      nextSteps: [
+        `Ensure you are logged in to the correct shop (currently: ${session.storeFqdn})`,
+        `Create a new Hydrogen storefront: Run \`${await getCliCommand(
+          root
+        )} link\` or visit ${newHydrogenStorefrontUrl(session)}`
+      ]
+    });
   }
 }
 const dateFormat = new Intl.DateTimeFormat("default", {
@@ -84,4 +94,4 @@ const pluralizedStorefronts = ({
   );
 };
 
-export { List as default, formatDeployment, listStorefronts };
+export { List as default, formatDeployment, runList };

package/dist/commands/hydrogen/list.test.js

@@ -1,83 +1,86 @@
 import { vi, describe, beforeEach, afterEach, it, expect } from 'vitest';
 import { mockAndCaptureOutput } from '@shopify/cli-kit/node/testing/output';
 import { getStorefrontsWithDeployment } from '../../lib/graphql/admin/list-storefronts.js';
-import { listStorefronts, formatDeployment } from './list.js';
+import { runList, formatDeployment } from './list.js';
+import { login } from '../../lib/auth.js';
 
-const SHOP_NAME = "my-shop";
-vi.mock("../../lib/graphql/admin/list-storefronts.js", async () => {
-  return { getStorefrontsWithDeployment: vi.fn() };
-});
-vi.mock("../../lib/shop.js", () => ({
-  getHydrogenShop: () => SHOP_NAME
-}));
+vi.mock("../../lib/auth.js");
+vi.mock("../../lib/graphql/admin/list-storefronts.js");
 describe("list", () => {
   const ADMIN_SESSION = {
     token: "abc123",
-    storeFqdn: SHOP_NAME
+    storeFqdn: "my-shop"
+  };
+  const SHOPIFY_CONFIG = {
+    shop: "my-shop.myshopify.com",
+    shopName: "My Shop",
+    email: "email",
+    storefront: {
+      id: "gid://shopify/HydrogenStorefront/1",
+      title: "Hydrogen"
+    }
   };
   beforeEach(async () => {
-    vi.mocked(getStorefrontsWithDeployment).mockResolvedValue({
-      adminSession: ADMIN_SESSION,
-      storefronts: []
+    vi.mocked(login).mockResolvedValue({
+      session: ADMIN_SESSION,
+      config: SHOPIFY_CONFIG
     });
+    vi.mocked(getStorefrontsWithDeployment).mockResolvedValue([]);
   });
   afterEach(() => {
     vi.resetAllMocks();
     mockAndCaptureOutput().clear();
   });
-  it("makes a GraphQL call to fetch the storefronts", async () => {
-    await listStorefronts({});
-    expect(getStorefrontsWithDeployment).toHaveBeenCalledWith(SHOP_NAME);
+  it("fetches the storefronts", async () => {
+    await runList({});
+    expect(getStorefrontsWithDeployment).toHaveBeenCalledWith(ADMIN_SESSION);
   });
   describe("and there are storefronts", () => {
     beforeEach(() => {
-      vi.mocked(getStorefrontsWithDeployment).mockResolvedValue({
-        adminSession: ADMIN_SESSION,
-        storefronts: [
-          {
-            id: "gid://shopify/HydrogenStorefront/1",
-            parsedId: "1",
-            title: "Hydrogen",
-            productionUrl: "https://example.com",
-            currentProductionDeployment: null
-          },
-          {
-            id: "gid://shopify/HydrogenStorefront/2",
-            parsedId: "2",
-            title: "Demo Store",
-            productionUrl: "https://demo.example.com",
-            currentProductionDeployment: {
-              id: "gid://shopify/HydrogenStorefrontDeployment/1",
-              createdAt: "2023-03-22T22:28:38Z",
-              commitMessage: "Update README.md"
-            }
+      vi.mocked(getStorefrontsWithDeployment).mockResolvedValue([
+        {
+          id: "gid://shopify/HydrogenStorefront/1",
+          parsedId: "1",
+          title: "Hydrogen",
+          productionUrl: "https://example.com",
+          currentProductionDeployment: null
+        },
+        {
+          id: "gid://shopify/HydrogenStorefront/2",
+          parsedId: "2",
+          title: "Demo Store",
+          productionUrl: "https://demo.example.com",
+          currentProductionDeployment: {
+            id: "gid://shopify/HydrogenStorefrontDeployment/1",
+            createdAt: "2023-03-22T22:28:38Z",
+            commitMessage: "Update README.md"
           }
-        ]
-      });
+        }
+      ]);
     });
     it("renders a list of storefronts", async () => {
       const outputMock = mockAndCaptureOutput();
-      await listStorefronts({});
+      await runList({});
       expect(outputMock.info()).toMatch(
-        /Showing 2 Hydrogen storefronts for the store my-shop/g
+        /Showing 2 Hydrogen storefronts for the store my-shop/i
       );
-      expect(outputMock.info()).toMatch(/Hydrogen \(id: 1\)/g);
-      expect(outputMock.info()).toMatch(/https:\/\/example.com/g);
-      expect(outputMock.info()).toMatch(/Demo Store \(id: 2\)/g);
-      expect(outputMock.info()).toMatch(/https:\/\/demo.example.com/g);
-      expect(outputMock.info()).toMatch(/3\/22\/2023, Update README.md/g);
+      expect(outputMock.info()).toMatch(/Hydrogen \(id: 1\)/);
+      expect(outputMock.info()).toMatch(/https:\/\/example.com/);
+      expect(outputMock.info()).toMatch(/Demo Store \(id: 2\)/);
+      expect(outputMock.info()).toMatch(/https:\/\/demo.example.com/);
+      expect(outputMock.info()).toMatch(/3\/22\/2023, Update README.md/);
     });
   });
   describe("and there are no storefronts", () => {
     it("prompts the user to create a storefront", async () => {
       const outputMock = mockAndCaptureOutput();
-      await listStorefronts({});
+      await runList({});
       expect(outputMock.info()).toMatch(
-        /There are no Hydrogen storefronts on your Shop\./g
+        /There are no Hydrogen storefronts on your Shop\./i
       );
-      expect(outputMock.info()).toMatch(/Create a new Hydrogen storefront/g);
+      expect(outputMock.info()).toMatch(/Create a new Hydrogen storefront/i);
       expect(outputMock.info()).toMatch(
-        /https:\/\/my\-shop\/admin\/custom_storefronts\/new/g
+        /https:\/\/my\-shop\/admin\/custom_storefronts\/new/
       );
     });
   });

package/dist/commands/hydrogen/login.js

@@ -0,0 +1,31 @@
+import { Flags } from '@oclif/core';
+import Command from '@shopify/cli-kit/node/base-command';
+import { normalizeStoreFqdn } from '@shopify/cli-kit/node/context/fqdn';
+import { commonFlags } from '../../lib/flags.js';
+import { login, renderLoginSuccess } from '../../lib/auth.js';
+
+class Login extends Command {
+  static description = "Login to your Shopify account.";
+  static flags = {
+    path: commonFlags.path,
+    shop: Flags.string({
+      char: "s",
+      description: "Shop URL. It can be the shop prefix (janes-apparel) or the full myshopify.com URL (janes-apparel.myshopify.com, https://janes-apparel.myshopify.com).",
+      env: "SHOPIFY_SHOP",
+      parse: async (input) => normalizeStoreFqdn(input)
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(Login);
+    await runLogin(flags);
+  }
+}
+async function runLogin({
+  path: root = process.cwd(),
+  shop: shopFlag
+}) {
+  const { config } = await login(root, shopFlag ?? true);
+  renderLoginSuccess(config);
+}
+
+export { Login as default };

package/dist/commands/hydrogen/logout.js

@@ -0,0 +1,21 @@
+import Command from '@shopify/cli-kit/node/base-command';
+import { renderSuccess } from '@shopify/cli-kit/node/ui';
+import { commonFlags } from '../../lib/flags.js';
+import { logout } from '../../lib/auth.js';
+
+class Logout extends Command {
+  static description = "Logout of your local session.";
+  static flags = {
+    path: commonFlags.path
+  };
+  async run() {
+    const { flags } = await this.parse(Logout);
+    await runLogout(flags);
+  }
+}
+async function runLogout({ path: root = process.cwd() }) {
+  await logout(root);
+  renderSuccess({ body: "You are logged out from Shopify." });
+}
+
+export { Logout as default };

package/dist/commands/hydrogen/preview.js

@@ -23,12 +23,13 @@ async function runPreview({
     process.env.NODE_ENV = "production";
   muteDevLogs({ workerReload: false });
   const { root, buildPathWorkerFile, buildPathClient } = getProjectPaths(appPath);
-  await startMiniOxygen({
+  const miniOxygen = await startMiniOxygen({
     root,
     port,
     buildPathClient,
     buildPathWorkerFile
   });
+  miniOxygen.showBanner({ mode: "preview" });
 }
 
 export { Preview as default, runPreview };

package/dist/commands/hydrogen/setup/css.js

@@ -0,0 +1,79 @@
+import { resolvePath } from '@shopify/cli-kit/node/path';
+import { commonFlags, overrideFlag, flagsToCamelObject } from '../../../lib/flags.js';
+import Command from '@shopify/cli-kit/node/base-command';
+import { renderTasks, renderSuccess } from '@shopify/cli-kit/node/ui';
+import { getPackageManager, installNodeModules } from '@shopify/cli-kit/node/node-package-manager';
+import { Args } from '@oclif/core';
+import { getRemixConfig } from '../../../lib/config.js';
+import { SETUP_CSS_STRATEGIES, renderCssPrompt, setupCssStrategy, CSS_STRATEGY_NAME_MAP } from '../../../lib/setups/css/index.js';
+
+class SetupCSS extends Command {
+  static description = "Setup CSS strategies for your project.";
+  static flags = {
+    path: commonFlags.path,
+    force: commonFlags.force,
+    "install-deps": overrideFlag(commonFlags.installDeps, { default: true })
+  };
+  static args = {
+    strategy: Args.string({
+      name: "strategy",
+      description: `The CSS strategy to setup. One of ${SETUP_CSS_STRATEGIES.join()}`,
+      options: SETUP_CSS_STRATEGIES
+    })
+  };
+  async run() {
+    const { flags, args } = await this.parse(SetupCSS);
+    const directory = flags.path ? resolvePath(flags.path) : process.cwd();
+    await runSetupCSS({
+      ...flagsToCamelObject(flags),
+      strategy: args.strategy,
+      directory
+    });
+  }
+}
+async function runSetupCSS({
+  strategy: flagStrategy,
+  directory,
+  force = false,
+  installDeps = true
+}) {
+  const remixConfigPromise = getRemixConfig(directory);
+  const strategy = flagStrategy ? flagStrategy : await renderCssPrompt();
+  const remixConfig = await remixConfigPromise;
+  const setupOutput = await setupCssStrategy(strategy, remixConfig, force);
+  if (!setupOutput)
+    return;
+  const { workPromise, generatedAssets, helpUrl } = setupOutput;
+  const tasks = [
+    {
+      title: "Updating files",
+      task: async () => {
+        await workPromise;
+      }
+    }
+  ];
+  if (installDeps) {
+    const gettingPkgManagerPromise = getPackageManager(
+      remixConfig.rootDirectory
+    );
+    tasks.push({
+      title: "Installing new dependencies",
+      task: async () => {
+        const packageManager = await gettingPkgManagerPromise;
+        await installNodeModules({
+          directory: remixConfig.rootDirectory,
+          packageManager,
+          args: []
+        });
+      }
+    });
+  }
+  await renderTasks(tasks);
+  renderSuccess({
+    headline: `${CSS_STRATEGY_NAME_MAP[strategy]} setup complete.`,
+    body: (generatedAssets.length > 0 ? "You can now modify CSS configuration in the following files:\n" + generatedAssets.map((file) => `  - ${file}`).join("\n") + "\n" : "") + `
+For more information, visit ${helpUrl}.`
+  });
+}
+
+export { SetupCSS as default, runSetupCSS };

package/dist/commands/hydrogen/setup/markets.js

@@ -0,0 +1,53 @@
+import { resolvePath } from '@shopify/cli-kit/node/path';
+import { commonFlags, flagsToCamelObject } from '../../../lib/flags.js';
+import Command from '@shopify/cli-kit/node/base-command';
+import { renderTasks, renderSuccess } from '@shopify/cli-kit/node/ui';
+import { Args } from '@oclif/core';
+import { getRemixConfig } from '../../../lib/config.js';
+import { SETUP_I18N_STRATEGIES, renderI18nPrompt, setupI18nStrategy, I18N_STRATEGY_NAME_MAP } from '../../../lib/setups/i18n/index.js';
+
+class SetupMarkets extends Command {
+  static description = "Setup support for multiple markets in your project.";
+  static flags = {
+    path: commonFlags.path
+  };
+  static args = {
+    strategy: Args.string({
+      name: "strategy",
+      description: `The URL structure strategy to setup multiple markets. One of ${SETUP_I18N_STRATEGIES.join()}`,
+      options: SETUP_I18N_STRATEGIES
+    })
+  };
+  async run() {
+    const { flags, args } = await this.parse(SetupMarkets);
+    const directory = flags.path ? resolvePath(flags.path) : process.cwd();
+    await runSetupI18n({
+      ...flagsToCamelObject(flags),
+      strategy: args.strategy,
+      directory
+    });
+  }
+}
+async function runSetupI18n({
+  strategy: flagStrategy,
+  directory
+}) {
+  const remixConfigPromise = getRemixConfig(directory);
+  const strategy = flagStrategy ? flagStrategy : await renderI18nPrompt();
+  const remixConfig = await remixConfigPromise;
+  await renderTasks([
+    {
+      title: "Updating files",
+      task: async () => {
+        await setupI18nStrategy(strategy, remixConfig);
+      }
+    }
+  ]);
+  renderSuccess({
+    headline: `Makerts support setup complete with strategy ${I18N_STRATEGY_NAME_MAP[strategy].toLocaleLowerCase()}.`,
+    body: `You can now modify the supported locales in ${remixConfig.serverEntryPoint ?? "your server entry file."}
+`
+  });
+}
+
+export { SetupMarkets as default, runSetupI18n };