shop-cli 0.1.1

package/dist/cli/verbs/gift-cards.js

@@ -0,0 +1,359 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gift_cards_exports = {};
+__export(gift_cards_exports, {
+  runGiftCards: () => runGiftCards
+});
+module.exports = __toCommonJS(gift_cards_exports);
+var import_errors = require("../errors");
+var import_input = require("../input");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_userErrors = require("../userErrors");
+var import_shared = require("./_shared");
+const giftCardSummarySelection = {
+  id: true,
+  balance: { amount: true, currencyCode: true },
+  initialValue: { amount: true, currencyCode: true },
+  lastCharacters: true,
+  expiresOn: true,
+  enabled: true,
+  createdAt: true,
+  updatedAt: true
+};
+const giftCardFullSelection = {
+  ...giftCardSummarySelection,
+  deactivatedAt: true,
+  maskedCode: true,
+  note: true,
+  templateSuffix: true,
+  customer: { id: true, displayName: true, email: true },
+  order: { id: true, name: true },
+  recipientAttributes: {
+    message: true,
+    preferredName: true,
+    sendNotificationAt: true,
+    recipient: { id: true, displayName: true, email: true, firstName: true, lastName: true }
+  }
+};
+const giftCardConfigurationSelection = {
+  expirationConfiguration: { expirationUnit: true, expirationValue: true },
+  issueLimit: { amount: true, currencyCode: true },
+  purchaseLimit: { amount: true, currencyCode: true }
+};
+const giftCardTransactionSelection = {
+  id: true,
+  amount: { amount: true, currencyCode: true },
+  processedAt: true,
+  note: true,
+  giftCard: { id: true }
+};
+const getGiftCardSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return giftCardFullSelection;
+  if (view === "raw") return {};
+  return giftCardSummarySelection;
+};
+const parseMoneyInput = (flag, value) => {
+  if (typeof value !== "string" || !value.trim()) throw new import_errors.CliError(`Missing ${flag}`, 2);
+  const raw = value.trim();
+  if (raw.startsWith("{")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      throw new import_errors.CliError(`${flag} must be valid JSON: ${err.message}`, 2);
+    }
+    if (parsed === null || typeof parsed !== "object") {
+      throw new import_errors.CliError(`${flag} must be a JSON object with amount and currencyCode`, 2);
+    }
+    if (parsed.amount === void 0 || parsed.currencyCode === void 0) {
+      throw new import_errors.CliError(`${flag} must include amount and currencyCode`, 2);
+    }
+    return parsed;
+  }
+  const parts = raw.split(/[,:\s]+/).map((part) => part.trim()).filter(Boolean);
+  if (parts.length !== 2) {
+    throw new import_errors.CliError(`${flag} must be in the form "amount,currency" (for example 10.00,USD)`, 2);
+  }
+  const [amount, currencyCode] = parts;
+  if (!amount || !currencyCode) {
+    throw new import_errors.CliError(`${flag} must include amount and currency`, 2);
+  }
+  return { amount, currencyCode: currencyCode.toUpperCase() };
+};
+const ensureObjectInput = (value, label) => {
+  if (value === null || typeof value !== "object") throw new import_errors.CliError(`${label} must be an object`, 2);
+  return value;
+};
+const runGiftCards = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage: shop gift-cards <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create            Create a gift card",
+        "  get               Get a gift card by ID",
+        "  list              List gift cards",
+        "  count             Count gift cards",
+        "  update            Update a gift card",
+        "  credit            Credit a gift card",
+        "  debit             Debit a gift card",
+        "  deactivate        Deactivate a gift card",
+        "  notify-customer   Send a gift card notification to the customer",
+        "  notify-recipient  Send a gift card notification to the recipient",
+        "  config            Get gift card configuration",
+        "",
+        "Common output flags:",
+        "  --view summary|ids|full|raw",
+        "  --select <path>        (repeatable; dot paths; adds to base view selection)",
+        "  --selection <graphql>  (selection override; can be @file.gql)",
+        "",
+        "Special flags:",
+        "  --credit-amount <amount,currency>  (credit)",
+        "  --debit-amount <amount,currency>   (debit)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "GiftCard");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "gift-cards",
+      view: ctx.view,
+      baseSelection: getGiftCardSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { giftCard: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.giftCard, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const query = args.query;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "gift-cards",
+      view: ctx.view,
+      baseSelection: getGiftCardSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      giftCards: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.giftCards,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("gift-cards", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  if (verb === "count") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const query = args.query;
+    const result = await (0, import_router.runQuery)(ctx, { giftCardsCount: { __args: { query }, count: true, precision: true } });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.giftCardsCount?.count ?? "");
+    (0, import_output.printJson)(result.giftCardsCount, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "config") {
+    const result = await (0, import_router.runQuery)(ctx, { giftCardConfiguration: giftCardConfigurationSelection });
+    if (result === void 0) return;
+    (0, import_output.printJson)(result.giftCardConfiguration, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "create") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      giftCardCreate: {
+        __args: { input: built.input },
+        giftCard: giftCardSummarySelection,
+        giftCardCode: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.giftCardCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.giftCardCreate?.giftCard?.id ?? "");
+    (0, import_output.printJson)(result.giftCardCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "GiftCard");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      giftCardUpdate: {
+        __args: { id, input: built.input },
+        giftCard: giftCardSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.giftCardUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.giftCardUpdate?.giftCard?.id ?? "");
+    (0, import_output.printJson)(result.giftCardUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "credit") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "credit-amount": { type: "string" } } });
+    const id = (0, import_shared.requireId)(args.id, "GiftCard");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const creditInput = built.used ? ensureObjectInput(built.input, "Gift card credit input") : {};
+    if (args["credit-amount"] !== void 0) {
+      creditInput.creditAmount = parseMoneyInput("--credit-amount", args["credit-amount"]);
+    }
+    if (creditInput.creditAmount === void 0) {
+      throw new import_errors.CliError("Missing --credit-amount or creditAmount in --input/--set", 2);
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      giftCardCredit: {
+        __args: { id, creditInput },
+        giftCardCreditTransaction: giftCardTransactionSelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.giftCardCredit, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.giftCardCredit?.giftCardCreditTransaction?.id ?? "");
+    (0, import_output.printJson)(result.giftCardCredit, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "debit") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "debit-amount": { type: "string" } } });
+    const id = (0, import_shared.requireId)(args.id, "GiftCard");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const debitInput = built.used ? ensureObjectInput(built.input, "Gift card debit input") : {};
+    if (args["debit-amount"] !== void 0) {
+      debitInput.debitAmount = parseMoneyInput("--debit-amount", args["debit-amount"]);
+    }
+    if (debitInput.debitAmount === void 0) {
+      throw new import_errors.CliError("Missing --debit-amount or debitAmount in --input/--set", 2);
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      giftCardDebit: {
+        __args: { id, debitInput },
+        giftCardDebitTransaction: giftCardTransactionSelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.giftCardDebit, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.giftCardDebit?.giftCardDebitTransaction?.id ?? "");
+    (0, import_output.printJson)(result.giftCardDebit, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "deactivate") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "GiftCard");
+    const result = await (0, import_router.runMutation)(ctx, {
+      giftCardDeactivate: {
+        __args: { id },
+        giftCard: giftCardSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.giftCardDeactivate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.giftCardDeactivate?.giftCard?.id ?? "");
+    (0, import_output.printJson)(result.giftCardDeactivate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "notify-customer") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "GiftCard");
+    const result = await (0, import_router.runMutation)(ctx, {
+      giftCardSendNotificationToCustomer: {
+        __args: { id },
+        giftCard: giftCardSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.giftCardSendNotificationToCustomer, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.giftCardSendNotificationToCustomer?.giftCard?.id ?? "");
+    (0, import_output.printJson)(result.giftCardSendNotificationToCustomer, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "notify-recipient") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "GiftCard");
+    const result = await (0, import_router.runMutation)(ctx, {
+      giftCardSendNotificationToRecipient: {
+        __args: { id },
+        giftCard: giftCardSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.giftCardSendNotificationToRecipient, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.giftCardSendNotificationToRecipient?.giftCard?.id ?? "");
+    (0, import_output.printJson)(result.giftCardSendNotificationToRecipient, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for gift-cards: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runGiftCards
+});
+//# sourceMappingURL=gift-cards.js.map

package/dist/cli/verbs/graphql.d.ts

@@ -0,0 +1,14 @@
+import { type CommandContext } from '../router';
+type GraphQLCommandContext = CommandContext & {
+    shopDomain?: string;
+    graphqlEndpoint?: string;
+    accessToken?: string;
+    apiVersion?: string;
+    headers?: Record<string, string>;
+};
+export declare const runGraphQL: ({ ctx, verb, argv, }: {
+    ctx: GraphQLCommandContext;
+    verb: string;
+    argv: string[];
+}) => Promise<void>;
+export {};

package/dist/cli/verbs/graphql.js

@@ -0,0 +1,285 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graphql_exports = {};
+__export(graphql_exports, {
+  runGraphQL: () => runGraphQL
+});
+module.exports = __toCommonJS(graphql_exports);
+var import_node_util = require("node:util");
+var import_node_fs = require("node:fs");
+var import_errors = require("../errors");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_adminClient = require("../../adminClient");
+var import_graphqlValidator = require("../../graphqlValidator");
+const printHelp = () => {
+  console.log(
+    [
+      "Usage:",
+      "  shop graphql query <graphql> [flags]",
+      "  shop graphql mutation <graphql> [flags]",
+      "  shop graphql <graphql> [flags]",
+      "  shop graphql nodes --ids <gid,gid,...> [flags]",
+      "  shop graphql shopifyql --query <string> [flags]",
+      "",
+      "Execute raw GraphQL queries and mutations against the Shopify Admin API.",
+      "",
+      "Arguments:",
+      "  <graphql>              GraphQL query/mutation (inline or @file.graphql)",
+      "",
+      "Variables:",
+      "  --var <name>=<value>      Set a string variable (repeatable)",
+      "  --var-json <name>=<json>  Set a variable with JSON value (repeatable)",
+      "  --variables <json>        Variables as JSON object (or @file.json)",
+      "  --operation <name>        Operation name (for multi-operation documents)",
+      "",
+      "Validation:",
+      "  Queries are validated against the bundled Shopify Admin schema before",
+      "  execution. This catches errors locally with helpful messages, without",
+      "  making an API request.",
+      "",
+      "  --no-validate             Skip local schema validation",
+      "",
+      "Output:",
+      "  --format json|jsonl|raw   Output format (default: json)",
+      "  --include-extensions      Include extensions in output",
+      "",
+      "Examples:",
+      "  # Simple query",
+      "  shop graphql query '{ shop { name } }'",
+      "",
+      "  # Query from file",
+      "  shop graphql query @get-products.graphql",
+      "",
+      "  # Query with variables",
+      "  shop graphql query 'query GetProduct($id: ID!) { product(id: $id) { title } }' \\",
+      "    --var id=gid://shopify/Product/123",
+      "",
+      "  # Mutation",
+      `  shop graphql mutation 'mutation { productCreate(input: { title: "Test" }) { product { id } } }'`,
+      "",
+      "  # Auto-detect query vs mutation",
+      "  shop graphql '{ shop { name } }'",
+      "",
+      "  # Fetch nodes by ID",
+      "  shop graphql nodes --ids gid://shopify/Product/1,gid://shopify/Order/2",
+      "",
+      "  # Run a ShopifyQL query",
+      '  shop graphql shopifyql --query "FROM products SHOW title"',
+      "",
+      "  # With JSON variables from file",
+      "  shop graphql @query.graphql --variables @vars.json",
+      "",
+      "  # Skip validation for edge cases",
+      "  shop graphql '{ shop { name } }' --no-validate"
+    ].join("\n")
+  );
+};
+const readTextArg = (value) => {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("@file:")) return (0, import_node_fs.readFileSync)(trimmed.slice("@file:".length), "utf8");
+  if (trimmed.startsWith("@")) return (0, import_node_fs.readFileSync)(trimmed.slice(1), "utf8");
+  return trimmed;
+};
+const parseVariables = ({
+  varArgs,
+  varJsonArgs,
+  variablesArg
+}) => {
+  const vars = {};
+  let hasVars = false;
+  if (variablesArg) {
+    const raw = readTextArg(variablesArg);
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new import_errors.CliError("--variables must be a JSON object", 2);
+      }
+      Object.assign(vars, parsed);
+      hasVars = true;
+    } catch (err) {
+      if (err instanceof import_errors.CliError) throw err;
+      throw new import_errors.CliError(`--variables must be valid JSON: ${err.message}`, 2);
+    }
+  }
+  if (varArgs) {
+    for (const arg of varArgs) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx === -1) throw new import_errors.CliError(`Invalid --var: expected name=value, got "${arg}"`, 2);
+      const name = arg.slice(0, eqIdx);
+      const value = arg.slice(eqIdx + 1);
+      if (!name) throw new import_errors.CliError(`Invalid --var: missing variable name in "${arg}"`, 2);
+      vars[name] = value;
+      hasVars = true;
+    }
+  }
+  if (varJsonArgs) {
+    for (const arg of varJsonArgs) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx === -1) throw new import_errors.CliError(`Invalid --var-json: expected name=json, got "${arg}"`, 2);
+      const name = arg.slice(0, eqIdx);
+      const jsonStr = arg.slice(eqIdx + 1);
+      if (!name) throw new import_errors.CliError(`Invalid --var-json: missing variable name in "${arg}"`, 2);
+      try {
+        vars[name] = JSON.parse(jsonStr);
+        hasVars = true;
+      } catch (err) {
+        throw new import_errors.CliError(`Invalid --var-json "${name}": ${err.message}`, 2);
+      }
+    }
+  }
+  return hasVars ? vars : void 0;
+};
+const runGraphQL = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h") || verb === "help") {
+    printHelp();
+    return;
+  }
+  if (verb === "nodes") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const raw = args.ids;
+    const values = Array.isArray(raw) ? raw : raw === void 0 ? [] : [raw];
+    const ids = [];
+    for (const v of values) {
+      if (typeof v !== "string") throw new import_errors.CliError("--ids must be a string", 2);
+      ids.push(...v.split(",").map((s) => s.trim()).filter(Boolean));
+    }
+    if (ids.length === 0) throw new import_errors.CliError("Missing --ids", 2);
+    const result = await (0, import_router.runQuery)(ctx, {
+      nodes: {
+        __args: { ids },
+        __typename: true,
+        id: true
+      }
+    });
+    if (result === void 0) return;
+    if (ctx.quiet) {
+      (0, import_output.printIds)((result.nodes ?? []).map((n) => n?.id));
+      return;
+    }
+    (0, import_output.printJson)(result.nodes, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "shopifyql") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const query2 = args.query;
+    if (!query2) throw new import_errors.CliError("Missing --query", 2);
+    const result = await (0, import_router.runQuery)(ctx, {
+      shopifyqlQuery: {
+        __args: { query: query2 },
+        parseErrors: true,
+        tableData: {
+          columns: { name: true, displayName: true, dataType: true, subType: true },
+          rows: true
+        }
+      }
+    });
+    if (result === void 0) return;
+    if (ctx.quiet) return;
+    (0, import_output.printJson)(result.shopifyqlQuery, ctx.format !== "raw");
+    return;
+  }
+  let actualVerb = verb;
+  let verbGraphQL;
+  if (verb === "query" || verb.startsWith("query")) {
+    const parts = verb.split(" ");
+    actualVerb = "query";
+    verbGraphQL = parts.slice(1).join(" ").trim() || void 0;
+  } else if (verb === "mutation" || verb.startsWith("mutation")) {
+    const parts = verb.split(" ");
+    actualVerb = "mutation";
+    verbGraphQL = parts.slice(1).join(" ").trim() || void 0;
+  }
+  const parsed = (0, import_node_util.parseArgs)({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      var: { type: "string", multiple: true },
+      "var-json": { type: "string", multiple: true },
+      variables: { type: "string" },
+      operation: { type: "string" },
+      "include-extensions": { type: "boolean" },
+      "no-validate": { type: "boolean" },
+      help: { type: "boolean" },
+      h: { type: "boolean" }
+    }
+  });
+  let querySource;
+  if (actualVerb === "query" || actualVerb === "mutation") {
+    querySource = verbGraphQL ?? parsed.positionals[0];
+  } else if (verb) {
+    querySource = verb;
+  }
+  if (!querySource) {
+    throw new import_errors.CliError("Missing GraphQL query/mutation. Use: shop graphql <query> or shop graphql query <query>", 2);
+  }
+  const query = readTextArg(querySource);
+  const variables = parseVariables({
+    varArgs: parsed.values.var,
+    varJsonArgs: parsed.values["var-json"],
+    variablesArg: parsed.values.variables
+  });
+  const request = {
+    query,
+    ...variables ? { variables } : {},
+    ...parsed.values.operation ? { operationName: parsed.values.operation } : {}
+  };
+  if (ctx.dryRun) {
+    (0, import_output.printJson)(request, ctx.format !== "raw");
+    return;
+  }
+  if (!parsed.values["no-validate"] && ctx.apiVersion) {
+    const validation = (0, import_graphqlValidator.validateGraphQL)(query, ctx.apiVersion);
+    if (!validation.valid) {
+      const errorMessage = (0, import_graphqlValidator.formatValidationErrors)(validation.errors);
+      console.error("GraphQL validation failed:\n");
+      console.error(errorMessage);
+      console.error("\nUse --no-validate to skip validation and send the request anyway.");
+      throw new import_errors.CliError("GraphQL validation failed", 1);
+    }
+  }
+  const rawClient = (0, import_adminClient.createRawGraphQLClient)({
+    shopDomain: ctx.shopDomain,
+    graphqlEndpoint: ctx.graphqlEndpoint,
+    accessToken: ctx.accessToken,
+    apiVersion: ctx.apiVersion,
+    headers: ctx.headers
+  });
+  let response;
+  try {
+    response = await rawClient.request(request);
+  } catch (err) {
+    throw new import_errors.CliError(`GraphQL request failed: ${err.message}`, 1);
+  }
+  if (response.errors && response.errors.length > 0) {
+    (0, import_output.printJsonError)({ errors: response.errors, data: response.data }, ctx.format !== "raw");
+    throw new import_errors.CliError("GraphQL request returned errors", 1);
+  }
+  const output = parsed.values["include-extensions"] ? response : response.data;
+  (0, import_output.printJson)(output, ctx.format !== "raw");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runGraphQL
+});
+//# sourceMappingURL=graphql.js.map

package/dist/cli/verbs/inventory-items.d.ts

@@ -0,0 +1,6 @@
+import { type CommandContext } from '../router';
+export declare const runInventoryItems: ({ ctx, verb, argv, }: {
+    ctx: CommandContext;
+    verb: string;
+    argv: string[];
+}) => Promise<void>;