@shopify/cli-hydrogen 4.1.1 → 4.1.2

package/dist/lib/graphql/admin/link-storefront.js

@@ -0,0 +1,11 @@
+const LinkStorefrontQuery = `#graphql
+  query LinkStorefront {
+    hydrogenStorefronts {
+      id
+      title
+      productionUrl
+    }
+  }
+`;
+
+export { LinkStorefrontQuery };

package/dist/lib/graphql/admin/list-storefronts.d.ts

@@ -0,0 +1,17 @@
+declare const ListStorefrontsQuery = "#graphql\n  query ListStorefronts {\n    hydrogenStorefronts {\n      id\n      title\n      productionUrl\n      currentProductionDeployment {\n        id\n        createdAt\n        commitMessage\n      }\n    }\n  }\n";
+interface Deployment {
+    id: string;
+    createdAt: string;
+    commitMessage: string | null;
+}
+interface HydrogenStorefront {
+    id: string;
+    title: string;
+    productionUrl?: string;
+    currentProductionDeployment: Deployment | null;
+}
+interface ListStorefrontsSchema {
+    hydrogenStorefronts: HydrogenStorefront[];
+}
+
+export { Deployment, ListStorefrontsQuery, ListStorefrontsSchema };

package/dist/lib/graphql/admin/list-storefronts.js

@@ -0,0 +1,16 @@
+const ListStorefrontsQuery = `#graphql
+  query ListStorefronts {
+    hydrogenStorefronts {
+      id
+      title
+      productionUrl
+      currentProductionDeployment {
+        id
+        createdAt
+        commitMessage
+      }
+    }
+  }
+`;
+
+export { ListStorefrontsQuery };

package/dist/lib/graphql/admin/pull-variables.d.ts

@@ -0,0 +1,16 @@
+declare const PullVariablesQuery = "#graphql\n  query ListStorefronts($id: ID!) {\n    hydrogenStorefront(id: $id) {\n      id\n      environmentVariables {\n        id\n        isSecret\n        key\n        value\n      }\n    }\n  }\n";
+interface EnvironmentVariable {
+    id: string;
+    isSecret: boolean;
+    key: string;
+    value: string;
+}
+interface HydrogenStorefront {
+    id: string;
+    environmentVariables: EnvironmentVariable[];
+}
+interface PullVariablesSchema {
+    hydrogenStorefront: HydrogenStorefront | null;
+}
+
+export { EnvironmentVariable, PullVariablesQuery, PullVariablesSchema };

package/dist/lib/graphql/admin/pull-variables.js

@@ -0,0 +1,15 @@
+const PullVariablesQuery = `#graphql
+  query ListStorefronts($id: ID!) {
+    hydrogenStorefront(id: $id) {
+      id
+      environmentVariables {
+        id
+        isSecret
+        key
+        value
+      }
+    }
+  }
+`;
+
+export { PullVariablesQuery };

package/dist/lib/graphql.d.ts

@@ -0,0 +1,21 @@
+import { GraphQLVariables } from '@shopify/cli-kit/node/api/graphql';
+import { AdminSession } from '@shopify/cli-kit/node/session';
+
+/**
+ * This is a temporary workaround until cli-kit includes a way to specify
+ * API versions for the Admin API because we need to target the unstable
+ * branch for this early access phase.
+ *
+ * @param query - GraphQL query to execute.
+ * @param session - Shopify admin session including token and Store FQDN.
+ * @param variables - GraphQL variables to pass to the query.
+ * @returns The response of the query of generic type <T>.
+ */
+declare function adminRequest<T>(query: string, session: AdminSession, variables?: GraphQLVariables): Promise<T>;
+/**
+ * @param gid a Global ID to parse (e.g. 'gid://shopify/HydrogenStorefront/1')
+ * @returns the ID of the record (e.g. '1')
+ */
+declare function parseGid(gid: string): string;
+
+export { adminRequest, parseGid };

package/dist/lib/graphql.js

@@ -0,0 +1,18 @@
+import { graphqlRequest } from '@shopify/cli-kit/node/api/graphql';
+import { AbortError } from '@shopify/cli-kit/node/error';
+
+async function adminRequest(query, session, variables) {
+  const api = "Admin";
+  const url = `https://${session.storeFqdn}/admin/api/unstable/graphql.json`;
+  return graphqlRequest({ query, api, url, token: session.token, variables });
+}
+const GID_REGEXP = /gid:\/\/shopify\/\w*\/(\d+)/;
+function parseGid(gid) {
+  const matches = GID_REGEXP.exec(gid);
+  if (matches && matches[1] !== void 0) {
+    return matches[1];
+  }
+  throw new AbortError(`Invalid Global ID: ${gid}`);
+}
+
+export { adminRequest, parseGid };

package/dist/lib/graphql.test.d.ts

@@ -0,0 +1 @@
+

package/dist/lib/graphql.test.js

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import { AbortError } from '@shopify/cli-kit/node/error';
+import { parseGid } from './graphql.js';
+
+describe("parseGid", () => {
+  it("returns an ID", () => {
+    const id = parseGid("gid://shopify/HydrogenStorefront/324");
+    expect(id).toStrictEqual("324");
+  });
+  describe("when the global ID is invalid", () => {
+    it("throws an error", () => {
+      expect(() => parseGid("321asd")).toThrow(AbortError);
+    });
+  });
+});

package/dist/lib/missing-storefronts.d.ts

@@ -0,0 +1,5 @@
+import { AdminSession } from '@shopify/cli-kit/node/session';
+
+declare function logMissingStorefronts(adminSession: AdminSession): void;
+
+export { logMissingStorefronts };

package/dist/lib/missing-storefronts.js

@@ -0,0 +1,18 @@
+import { renderInfo } from '@shopify/cli-kit/node/ui';
+import { newHydrogenStorefrontUrl } from './admin-urls.js';
+
+function logMissingStorefronts(adminSession) {
+  renderInfo({
+    headline: "Hydrogen storefronts",
+    body: "There are no Hydrogen storefronts on your Shop.",
+    nextSteps: [
+      `Ensure you have specified the correct shop (you specified: ${adminSession.storeFqdn})`,
+      `Ensure you have the Hydrogen sales channel installed https://apps.shopify.com/hydrogen`,
+      `Create a new Hydrogen storefront: ${newHydrogenStorefrontUrl(
+        adminSession
+      )}`
+    ]
+  });
+}
+
+export { logMissingStorefronts };

package/dist/lib/shop.d.ts

@@ -0,0 +1,7 @@
+interface Flags {
+    shop?: string;
+    path?: string;
+}
+declare function getHydrogenShop(flags: Flags): Promise<string>;
+
+export { getHydrogenShop };

package/dist/lib/shop.js

@@ -0,0 +1,32 @@
+import { renderTextPrompt } from '@shopify/cli-kit/node/ui';
+import { AbortError } from '@shopify/cli-kit/node/error';
+import { outputContent, outputToken } from '@shopify/cli-kit/node/output';
+import { getConfig, setShop } from './shopify-config.js';
+
+async function getHydrogenShop(flags) {
+  const { shop: flagShop, path: flagPath } = flags;
+  const targetPath = flagPath ?? process.cwd();
+  const { shop: configShop } = await getConfig(targetPath);
+  let promptShop;
+  if (!flagShop && !configShop) {
+    promptShop = await renderTextPrompt({
+      message: "Specify which Shop you would like to use (e.g. janes-goods.myshopify.com)",
+      allowEmpty: false
+    });
+  }
+  const shop = flagShop || configShop || promptShop;
+  if (!shop) {
+    throw new AbortError(
+      "A shop is required",
+      `Specify the shop passing ${outputContent`${outputToken.genericShellCommand(
+        `--shop={your_shop_url}}`
+      )}`.value} or set the ${outputContent`${outputToken.genericShellCommand("SHOPIFY_SHOP")}`.value} environment variable.`
+    );
+  }
+  if (!configShop || flagShop && flagShop != configShop) {
+    await setShop(targetPath, shop);
+  }
+  return shop;
+}
+
+export { getHydrogenShop };

package/dist/lib/shop.test.d.ts

@@ -0,0 +1 @@
+

package/dist/lib/shop.test.js

@@ -0,0 +1,78 @@
+import { vi, describe, beforeEach, afterEach, it, expect } from 'vitest';
+import { inTemporaryDirectory } from '@shopify/cli-kit/node/fs';
+import { AbortError } from '@shopify/cli-kit/node/error';
+import { mockAndCaptureOutput } from '@shopify/cli-kit/node/testing/output';
+import { renderTextPrompt } from '@shopify/cli-kit/node/ui';
+import { getHydrogenShop } from './shop.js';
+import { getConfig, setShop } from './shopify-config.js';
+
+vi.mock("@shopify/cli-kit/node/ui");
+vi.mock("./shopify-config.js");
+describe("getHydrogenShop()", () => {
+  beforeEach(() => {
+    vi.mocked(getConfig).mockResolvedValue({});
+  });
+  afterEach(() => {
+    mockAndCaptureOutput().clear();
+    vi.clearAllMocks();
+  });
+  describe("when a shop is passed via flag", () => {
+    it("returns the shop", async () => {
+      await inTemporaryDirectory(async (tmpDir) => {
+        const shop = await getHydrogenShop({ shop: "my-shop", path: tmpDir });
+        expect(shop).toBe("my-shop");
+      });
+    });
+  });
+  describe("when a shop is not provided via flag", () => {
+    describe("and there is no existing SHOP_NAME file", () => {
+      it("prompts the user to enter a new name", async () => {
+        await inTemporaryDirectory(async (tmpDir) => {
+          vi.mocked(renderTextPrompt).mockResolvedValue("my-prompted-shop");
+          const shop = await getHydrogenShop({ path: tmpDir });
+          expect(renderTextPrompt).toHaveBeenCalledWith({
+            message: "Specify which Shop you would like to use (e.g. janes-goods.myshopify.com)",
+            allowEmpty: false
+          });
+          expect(shop).toBe("my-prompted-shop");
+        });
+      });
+      describe("and the user does not enter a value", () => {
+        it("throws an error", async () => {
+          await inTemporaryDirectory(async (tmpDir) => {
+            vi.mocked(renderTextPrompt).mockResolvedValue("");
+            await expect(getHydrogenShop({ path: tmpDir })).rejects.toThrow(
+              AbortError
+            );
+          });
+        });
+      });
+    });
+    describe("and there is an existing shop from the config file", () => {
+      it("returns the shop", async () => {
+        vi.mocked(getConfig).mockResolvedValue({ shop: "previous-shop" });
+        await inTemporaryDirectory(async (tmpDir) => {
+          const shop = await getHydrogenShop({ path: tmpDir });
+          expect(shop).toBe("previous-shop");
+        });
+      });
+    });
+  });
+  describe("when the SHOP_NAME file does not exist", () => {
+    it("gets created", async () => {
+      await inTemporaryDirectory(async (tmpDir) => {
+        await getHydrogenShop({ shop: "new-shop", path: tmpDir });
+        expect(setShop).toHaveBeenCalledWith(tmpDir, "new-shop");
+      });
+    });
+  });
+  describe("when the shop is different from the value in SHOP_NAME", () => {
+    it("overwrites SHOP_NAME with the new value", async () => {
+      vi.mocked(getConfig).mockResolvedValue({ shop: "previous-shop" });
+      await inTemporaryDirectory(async (tmpDir) => {
+        await getHydrogenShop({ shop: "new-shop", path: tmpDir });
+        expect(setShop).toHaveBeenCalledWith(tmpDir, "new-shop");
+      });
+    });
+  });
+});

package/dist/lib/shopify-config.d.ts

@@ -0,0 +1,35 @@
+declare const SHOPIFY_DIR = ".shopify";
+declare const SHOPIFY_DIR_PROJECT = "project.json";
+interface Storefront {
+    id: string;
+    title: string;
+}
+interface ShopifyConfig {
+    shop?: string;
+    storefront?: Storefront;
+}
+declare function getConfig(root: string): Promise<ShopifyConfig>;
+declare function setShop(root: string, shop: string): Promise<ShopifyConfig>;
+/**
+ * Adds storefront information to the config
+ *
+ * @param root the target directory
+ * @returns the updated config
+ */
+declare function setStorefront(root: string, storefront: Storefront): Promise<ShopifyConfig>;
+/**
+ * Removes storefront information from the config
+ *
+ * @param root the target directory
+ * @returns the updated config
+ */
+declare function unsetStorefront(root: string): Promise<ShopifyConfig>;
+/**
+ * Conditionally adds .shopify to the directory's .gitignore file
+ * @param root
+ * @returns A boolean; true if the .gitignore was updated, false if there was
+ * an error or the .gitignore didn't need updating
+ */
+declare function ensureShopifyGitIgnore(root: string): Promise<boolean>;
+
+export { SHOPIFY_DIR, SHOPIFY_DIR_PROJECT, ShopifyConfig, ensureShopifyGitIgnore, getConfig, setShop, setStorefront, unsetStorefront };

package/dist/lib/shopify-config.js

@@ -0,0 +1,86 @@
+import { resolvePath, dirname } from '@shopify/cli-kit/node/path';
+import { fileExists, readFile, mkdir, writeFile } from '@shopify/cli-kit/node/fs';
+import { AbortError } from '@shopify/cli-kit/node/error';
+import { outputInfo } from '@shopify/cli-kit/node/output';
+
+const SHOPIFY_DIR = ".shopify";
+const SHOPIFY_DIR_PROJECT = "project.json";
+async function getConfig(root) {
+  const filePath = resolvePath(root, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT);
+  if (!await fileExists(filePath)) {
+    return {};
+  }
+  return JSON.parse(await readFile(filePath));
+}
+async function setShop(root, shop) {
+  const filePath = resolvePath(root, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT);
+  if (!await fileExists(filePath)) {
+    await mkdir(dirname(filePath));
+    const newConfig = {
+      shop
+    };
+    await writeFile(filePath, JSON.stringify(newConfig));
+    await ensureShopifyGitIgnore(root);
+    return newConfig;
+  }
+  const existingConfig = JSON.parse(await readFile(filePath));
+  const config = {
+    ...existingConfig,
+    shop
+  };
+  await writeFile(filePath, JSON.stringify(config));
+  await ensureShopifyGitIgnore(root);
+  return config;
+}
+async function setStorefront(root, storefront) {
+  try {
+    const filePath = resolvePath(root, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT);
+    const existingConfig = JSON.parse(await readFile(filePath));
+    const config = {
+      ...existingConfig,
+      storefront
+    };
+    await writeFile(filePath, JSON.stringify(config));
+    await ensureShopifyGitIgnore(root);
+    return config;
+  } catch {
+    throw new AbortError("Project configuration could not be found.");
+  }
+}
+async function unsetStorefront(root) {
+  try {
+    const filePath = resolvePath(root, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT);
+    const existingConfig = JSON.parse(await readFile(filePath));
+    const config = {
+      ...existingConfig,
+      storefront: void 0
+    };
+    await writeFile(filePath, JSON.stringify(config));
+    await ensureShopifyGitIgnore(root);
+    return config;
+  } catch {
+    throw new AbortError("Project configuration could not be found.");
+  }
+}
+async function ensureShopifyGitIgnore(root) {
+  try {
+    const gitIgnoreFilePath = resolvePath(root, ".gitignore");
+    let gitIgnoreContents = await fileExists(gitIgnoreFilePath) ? await readFile(gitIgnoreFilePath) : "";
+    if (gitIgnoreContents.includes(".shopify")) {
+      return false;
+    }
+    if (gitIgnoreContents.length > 0) {
+      gitIgnoreContents += `
+`;
+    }
+    gitIgnoreContents += `${SHOPIFY_DIR}\r
+`;
+    outputInfo("Adding .shopify to .gitignore...");
+    await writeFile(gitIgnoreFilePath, gitIgnoreContents);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { SHOPIFY_DIR, SHOPIFY_DIR_PROJECT, ensureShopifyGitIgnore, getConfig, setShop, setStorefront, unsetStorefront };

package/dist/lib/shopify-config.test.d.ts

@@ -0,0 +1 @@
+

package/dist/lib/shopify-config.test.js

@@ -0,0 +1,209 @@
+import { describe, it, expect } from 'vitest';
+import { inTemporaryDirectory, mkdir, writeFile, fileExists, readFile } from '@shopify/cli-kit/node/fs';
+import { joinPath, dirname } from '@shopify/cli-kit/node/path';
+import { getConfig, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT, setShop, setStorefront, unsetStorefront, ensureShopifyGitIgnore } from './shopify-config.js';
+
+describe("getConfig()", () => {
+  describe("when no config exists", () => {
+    it("returns an empty object", async () => {
+      await inTemporaryDirectory(async (tmpDir) => {
+        const config = await getConfig(tmpDir);
+        expect(config).toStrictEqual({});
+      });
+    });
+  });
+  describe("when a config exists", () => {
+    it("returns the config", async () => {
+      await inTemporaryDirectory(async (tmpDir) => {
+        const existingConfig = {
+          shop: "my-shop"
+        };
+        const filePath = joinPath(tmpDir, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT);
+        await mkdir(dirname(filePath));
+        await writeFile(filePath, JSON.stringify(existingConfig));
+        const config = await getConfig(tmpDir);
+        expect(config).toStrictEqual(existingConfig);
+      });
+    });
+  });
+});
+describe("setShop()", () => {
+  describe("when no config exists", () => {
+    it("creates a new config file", async () => {
+      await inTemporaryDirectory(async (tmpDir) => {
+        const filePath = joinPath(tmpDir, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT);
+        expect(await fileExists(filePath)).toBeFalsy();
+        await setShop(tmpDir, "new-shop");
+        expect(await fileExists(filePath)).toBeTruthy();
+      });
+    });
+    it("returns the new config", async () => {
+      await inTemporaryDirectory(async (tmpDir) => {
+        const config = await setShop(tmpDir, "new-shop");
+        expect(config).toStrictEqual({
+          shop: "new-shop"
+        });
+      });
+    });
+  });
+  describe("when a config exists", () => {
+    it("updates the config file", async () => {
+      await inTemporaryDirectory(async (tmpDir) => {
+        const existingConfig = {
+          shop: "previous-shop",
+          storefront: {
+            id: "gid://shopify/HydrogenStorefront/1",
+            title: "Hydrogen"
+          }
+        };
+        const filePath = joinPath(tmpDir, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT);
+        await mkdir(dirname(filePath));
+        await writeFile(filePath, JSON.stringify(existingConfig));
+        expect(JSON.parse(await readFile(filePath))).toStrictEqual(
+          existingConfig
+        );
+        await setShop(tmpDir, "new-shop");
+        expect(JSON.parse(await readFile(filePath))).toStrictEqual({
+          ...existingConfig,
+          shop: "new-shop"
+        });
+      });
+    });
+    it("returns the new config", async () => {
+      await inTemporaryDirectory(async (tmpDir) => {
+        const existingConfig = {
+          shop: "previous-shop",
+          storefront: {
+            id: "gid://shopify/HydrogenStorefront/1",
+            title: "Hydrogen"
+          }
+        };
+        const filePath = joinPath(tmpDir, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT);
+        await mkdir(dirname(filePath));
+        await writeFile(filePath, JSON.stringify(existingConfig));
+        const config = await setShop(tmpDir, "new-shop");
+        expect(config).toStrictEqual({
+          ...existingConfig,
+          shop: "new-shop"
+        });
+      });
+    });
+  });
+});
+describe("setStorefront()", () => {
+  it("updates the config file", async () => {
+    await inTemporaryDirectory(async (tmpDir) => {
+      const existingConfig = {
+        shop: "previous-shop",
+        storefront: {
+          id: "gid://shopify/HydrogenStorefront/1",
+          title: "Hydrogen"
+        }
+      };
+      const filePath = joinPath(tmpDir, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT);
+      await mkdir(dirname(filePath));
+      await writeFile(filePath, JSON.stringify(existingConfig));
+      expect(JSON.parse(await readFile(filePath))).toStrictEqual(
+        existingConfig
+      );
+      const newStorefront = {
+        id: "gid://shopify/HydrogenStorefront/2",
+        title: "Remix"
+      };
+      await setStorefront(tmpDir, newStorefront);
+      expect(JSON.parse(await readFile(filePath))).toStrictEqual({
+        ...existingConfig,
+        storefront: newStorefront
+      });
+    });
+  });
+  it("returns the new config", async () => {
+    await inTemporaryDirectory(async (tmpDir) => {
+      const existingConfig = {
+        shop: "previous-shop",
+        storefront: {
+          id: "gid://shopify/HydrogenStorefront/1",
+          title: "Hydrogen"
+        }
+      };
+      const filePath = joinPath(tmpDir, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT);
+      await mkdir(dirname(filePath));
+      await writeFile(filePath, JSON.stringify(existingConfig));
+      const newStorefront = {
+        id: "gid://shopify/HydrogenStorefront/2",
+        title: "Remix"
+      };
+      const config = await setStorefront(tmpDir, newStorefront);
+      expect(config).toStrictEqual({
+        ...existingConfig,
+        storefront: newStorefront
+      });
+    });
+  });
+});
+describe("unsetStorefront()", () => {
+  it("removes the storefront configuration and returns the config", async () => {
+    await inTemporaryDirectory(async (tmpDir) => {
+      const existingConfig = {
+        shop: "previous-shop",
+        storefront: {
+          id: "gid://shopify/HydrogenStorefront/1",
+          title: "Hydrogen"
+        }
+      };
+      const filePath = joinPath(tmpDir, SHOPIFY_DIR, SHOPIFY_DIR_PROJECT);
+      await mkdir(dirname(filePath));
+      await writeFile(filePath, JSON.stringify(existingConfig));
+      expect(JSON.parse(await readFile(filePath))).toStrictEqual(
+        existingConfig
+      );
+      const config = await unsetStorefront(tmpDir);
+      expect(config).toStrictEqual({
+        shop: "previous-shop",
+        storefront: void 0
+      });
+      expect(JSON.parse(await readFile(filePath))).toStrictEqual({
+        shop: "previous-shop"
+      });
+    });
+  });
+});
+describe("ensureShopifyGitIgnore()", () => {
+  describe("when a .gitignore file already exists", () => {
+    it("updates the .gitignore file and returns true", async () => {
+      await inTemporaryDirectory(async (tmpDir) => {
+        const existingFileContents = "node_modules\r\n";
+        const filePath = joinPath(tmpDir, ".gitignore");
+        await writeFile(filePath, JSON.stringify(existingFileContents));
+        expect(await readFile(filePath)).not.toContain(".shopify");
+        const result = await ensureShopifyGitIgnore(tmpDir);
+        expect(await readFile(filePath)).toContain(".shopify");
+        expect(result).toBeTruthy();
+      });
+    });
+    describe("and the file is already ignoring .shopify", () => {
+      it("does not update the file and returns false", async () => {
+        await inTemporaryDirectory(async (tmpDir) => {
+          const existingFileContents = "node_modules\n.shopify\r\n";
+          const filePath = joinPath(tmpDir, ".gitignore");
+          await writeFile(filePath, JSON.stringify(existingFileContents));
+          const originalFile = await readFile(filePath);
+          const result = await ensureShopifyGitIgnore(tmpDir);
+          expect(await readFile(filePath)).toStrictEqual(originalFile);
+          expect(result).toBeFalsy();
+        });
+      });
+    });
+  });
+  describe("when a .gitignore does not exist", () => {
+    it("creates the .gitignore file and returns true", async () => {
+      await inTemporaryDirectory(async (tmpDir) => {
+        const filePath = joinPath(tmpDir, ".gitignore");
+        expect(await fileExists(filePath)).toBeFalsy();
+        const result = await ensureShopifyGitIgnore(tmpDir);
+        expect(await readFile(filePath)).toContain(".shopify");
+        expect(result).toBeTruthy();
+      });
+    });
+  });
+});