shop-cli 0.1.0

package/dist/cli/help/render.d.ts

@@ -0,0 +1,7 @@
+type VerbHelpOptions = {
+    showAllFields?: boolean;
+};
+export declare const renderTopLevelHelp: (command?: string) => string;
+export declare const renderResourceHelp: (resource: string, command?: string) => string | undefined;
+export declare const renderVerbHelp: (resourceName: string, verbName: string, options?: VerbHelpOptions, command?: string) => string | undefined;
+export {};

package/dist/cli/help/render.js

@@ -0,0 +1,352 @@
+"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 render_exports = {};
+__export(render_exports, {
+  renderResourceHelp: () => renderResourceHelp,
+  renderTopLevelHelp: () => renderTopLevelHelp,
+  renderVerbHelp: () => renderVerbHelp
+});
+module.exports = __toCommonJS(render_exports);
+var import_format = require("./format");
+var import_registry = require("./registry");
+var import_schema_help = require("../../generated/help/schema-help");
+var import_defaults = require("../../defaults");
+var import_command = require("../command");
+const PRIMITIVES = /* @__PURE__ */ new Set([
+  "String",
+  "Int",
+  "Float",
+  "Boolean",
+  "ID",
+  "DateTime",
+  "Date",
+  "JSON",
+  "Decimal",
+  "HTML",
+  "URL",
+  "Money",
+  "UnsignedInt64",
+  "FormattedString",
+  "Color",
+  "UtcOffset",
+  "ARN"
+]);
+const findResource = (resource) => import_registry.commandRegistry.find((entry) => entry.resource === resource);
+const findVerb = (resource, verb) => resource.verbs.find((entry) => entry.verb === verb);
+const formatEnumValues = (enumName) => {
+  const values = import_schema_help.enumTypeHelp[enumName];
+  if (!values) return void 0;
+  const names = values.map((value) => value.name);
+  if (names.length <= 6) return names.join("|");
+  return `${names.slice(0, 6).join("|")}|...`;
+};
+const formatType = (field) => {
+  const enumValues = formatEnumValues(field.typeName);
+  let label = enumValues ?? field.typeName;
+  if (field.isList) label = `${label}[]`;
+  return label;
+};
+const operationHelpFor = (spec) => {
+  if (!spec.operation) return void 0;
+  if (spec.operation.type === "mutation") return import_schema_help.mutationHelp[spec.operation.name];
+  return import_schema_help.queryHelp[spec.operation.name];
+};
+const inputFieldsFor = (spec) => {
+  if (!spec.input || spec.input.mode !== "set") return void 0;
+  const opHelp = operationHelpFor(spec);
+  const inputArg = spec.input.arg ?? spec.operation?.inputArg ?? "input";
+  const arg = opHelp?.args.find((item) => item.name === inputArg);
+  if (!arg) return void 0;
+  return import_schema_help.inputTypeHelp[arg.typeName];
+};
+const formatFieldFlags = (fields) => {
+  return fields.map((field) => {
+    const type = formatType(field);
+    const required = field.required ? "Required. " : "";
+    const description = field.description ? `${required}${field.description}` : required.trim() || void 0;
+    return {
+      label: `--set ${field.name}=<${type}>`,
+      description
+    };
+  });
+};
+const formatOutputFlags = (spec) => {
+  const flags = [];
+  if (spec.output?.view) flags.push(...import_registry.commonOutputFlags);
+  if (spec.output?.pagination) flags.push(...import_registry.paginationFlags);
+  return flags;
+};
+const getReferencedInputTypes = (fields) => {
+  const types = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    const typeName = field.typeName;
+    if (PRIMITIVES.has(typeName)) continue;
+    if (import_schema_help.enumTypeHelp[typeName]) continue;
+    if (!import_schema_help.inputTypeHelp[typeName]) continue;
+    if (seen.has(typeName)) continue;
+    seen.add(typeName);
+    types.push(typeName);
+  }
+  return types;
+};
+const collectNestedTypes = (fields, depth, visited) => {
+  const result = /* @__PURE__ */ new Map();
+  if (depth <= 0) return result;
+  for (const field of fields) {
+    const typeName = field.typeName;
+    if (PRIMITIVES.has(typeName)) continue;
+    if (import_schema_help.enumTypeHelp[typeName]) continue;
+    if (visited.has(typeName)) continue;
+    const nestedFields = import_schema_help.inputTypeHelp[typeName];
+    if (!nestedFields) continue;
+    visited.add(typeName);
+    result.set(typeName, nestedFields);
+    const deeper = collectNestedTypes(nestedFields, depth - 1, visited);
+    for (const [k, v] of deeper) {
+      result.set(k, v);
+    }
+  }
+  return result;
+};
+const formatFieldTypeWithMarkers = (field) => {
+  let label = field.typeName;
+  if (field.isList) label = `${label}[]`;
+  if (field.required) label = `${label}!`;
+  return label;
+};
+const wrapText = (text, width) => {
+  const words = text.split(/\s+/).filter(Boolean);
+  if (words.length === 0) return [""];
+  const lines = [];
+  let line = words[0];
+  for (let i = 1; i < words.length; i++) {
+    const word = words[i];
+    if (line.length + 1 + word.length > width) {
+      lines.push(line);
+      line = word;
+    } else {
+      line += ` ${word}`;
+    }
+  }
+  lines.push(line);
+  return lines;
+};
+const renderTypeShapesSection = (types, totalWidth = 108) => {
+  if (types.size === 0) return [];
+  const lines = ["Referenced types:"];
+  for (const [typeName, fields] of types) {
+    lines.push("");
+    lines.push(`  ${typeName}:`);
+    const nameWidth = Math.max(...fields.map((f) => f.name.length), 4);
+    const typeWidth = Math.max(...fields.map((f) => formatFieldTypeWithMarkers(f).length), 4);
+    for (const field of fields) {
+      const name = field.name.padEnd(nameWidth);
+      const type = formatFieldTypeWithMarkers(field).padEnd(typeWidth);
+      const required = field.required ? "Required. " : "";
+      const desc = field.description ?? "";
+      const prefix = `    ${name}  ${type}  `;
+      const indent = " ".repeat(prefix.length);
+      const descWidth = Math.max(20, totalWidth - prefix.length);
+      const normalizedDesc = `${required}${desc}`.split("\n").filter((line) => line.trim() !== "").join(" ");
+      const wrappedLines = wrapText(normalizedDesc, descWidth);
+      lines.push(`${prefix}${wrappedLines[0]}`);
+      for (let i = 1; i < wrappedLines.length; i++) {
+        lines.push(`${indent}${wrappedLines[i]}`);
+      }
+    }
+  }
+  return lines;
+};
+const formatTypeDetailsFooter = (typeNames, command) => {
+  if (typeNames.length === 0) return [];
+  const lines = ["Type details:"];
+  for (const typeName of typeNames) {
+    lines.push(`  ${command} types ${typeName}`);
+  }
+  return lines;
+};
+const formatWithCommand = (text, command) => (0, import_command.formatCommandRef)(text, command);
+const renderTopLevelHelp = (command = (0, import_command.resolveCliCommand)()) => {
+  const resources = [...import_registry.commandRegistry].filter((r) => r.resource !== "graphql").sort((a, b) => a.resource.localeCompare(b.resource));
+  const resourceLines = resources.map((resource) => {
+    const verbs = resource.verbs.map((verb) => verb.verb).join("|");
+    return `  ${resource.resource}: ${verbs}`;
+  });
+  return [
+    "Usage:",
+    `  ${command} <resource> <verb> [flags]`,
+    "",
+    "Resources:",
+    ...resourceLines,
+    "",
+    "Auth (flags override env):",
+    "  --shop <your-shop.myshopify.com>      (or env SHOPIFY_SHOP)",
+    "  --graphql-endpoint <url>          (or env GRAPHQL_ENDPOINT; overrides shop domain)",
+    "  --access-token <token>              (or env SHOPIFY_ACCESS_TOKEN)",
+    '  --header "Name: value"              (repeatable; also supports Name=value)',
+    `  (env SHOPIFY_HEADERS='{"Name":"value"}')`,
+    `  --api-version <YYYY-MM>             (default: ${import_defaults.DEFAULT_ADMIN_API_VERSION})`,
+    "",
+    "Output:",
+    "  --format json|jsonl|table|raw|markdown   (default: json)",
+    "  --view summary|ids|full|raw|all (default: summary)",
+    "  --select <path>           (repeatable; dot paths; adds to base view selection)",
+    "  --include <connection>    (repeatable; only used with --view all)",
+    "  --selection <graphql>     (selection override; can be @file.gql)",
+    "  --quiet                  (IDs only when possible)",
+    "",
+    "Debug:",
+    "  --dry-run                (print GraphQL op + variables, do not execute)",
+    "  --no-fail-on-user-errors (do not exit non-zero on userErrors)",
+    "",
+    "Raw GraphQL:",
+    `  ${command} graphql <query>              Execute raw GraphQL query or mutation`,
+    `  ${command} graphql @file.graphql        Execute query from file`,
+    "  --var <name>=<value>              Set a variable (repeatable)",
+    "  --variables <json>                Variables as JSON (or @file.json)",
+    "  --no-validate                     Skip local schema validation",
+    "",
+    "Schema introspection:",
+    `  ${command} types <TypeName>             Explore input types and enums`,
+    "",
+    "Examples:",
+    `  ${command} products list --first 5 --format table`,
+    `  ${command} products create --set title="Hat" --set status="ACTIVE"`,
+    `  ${command} products add-tags --id 123 --tags "summer,featured"`,
+    `  ${command} publications resolve --publication "Online Store"`,
+    `  ${command} products publish --id 123 --publication "Online Store" --now`,
+    `  ${command} products metafields upsert --id 123 --set namespace=custom --set key=foo --set type=single_line_text_field --set value=bar`
+  ].join("\n");
+};
+const renderResourceHelp = (resource, command = (0, import_command.resolveCliCommand)()) => {
+  const spec = findResource(resource);
+  if (!spec) return void 0;
+  const verbs = spec.verbs.map((verb) => verb.verb).join("|");
+  const lines = ["Usage:", `  ${command} ${spec.resource} <verb> [flags]`, ""];
+  if (spec.description) lines.push(spec.description, "");
+  lines.push("Verbs:", `  ${verbs}`, "");
+  if (spec.flags && spec.flags.length > 0) {
+    lines.push(...(0, import_format.formatSection)("Flags:", (0, import_format.formatFlags)({ flags: spec.flags })));
+    lines.push("");
+  }
+  if (spec.notes && spec.notes.length > 0) {
+    lines.push("Notes:");
+    for (const note of spec.notes) lines.push(`  ${formatWithCommand(note, command)}`);
+    lines.push("");
+  }
+  if (spec.examples && spec.examples.length > 0) {
+    lines.push("Examples:");
+    for (const example of spec.examples) lines.push(`  ${formatWithCommand(example, command)}`);
+    lines.push("");
+  }
+  if (spec.resource !== "graphql") {
+    const outputFlags = (0, import_format.formatFlags)({ flags: import_registry.commonOutputFlags });
+    lines.push(...(0, import_format.formatSection)("Common output flags:", outputFlags));
+  }
+  return lines.join("\n");
+};
+const renderVerbHelp = (resourceName, verbName, options = {}, command = (0, import_command.resolveCliCommand)()) => {
+  const resource = findResource(resourceName);
+  if (!resource) return void 0;
+  const spec = findVerb(resource, verbName);
+  if (!spec) return void 0;
+  const lines = [];
+  if (spec.description) lines.push(spec.description, "");
+  lines.push("Usage:");
+  lines.push(`  ${command} ${resource.resource} ${spec.verb} [flags]`);
+  lines.push("");
+  const requiredFlags = spec.requiredFlags ?? [];
+  if (requiredFlags.length > 0) {
+    lines.push(...(0, import_format.formatSection)("Required flags:", (0, import_format.formatFlags)({ flags: requiredFlags })));
+    lines.push("");
+  }
+  if (spec.input && spec.input.mode === "set") {
+    const title = spec.input.required ? "Input options (required):" : "Input options:";
+    lines.push(...(0, import_format.formatSection)(title, (0, import_format.formatFlags)({ flags: import_registry.standardInputFlags })));
+    lines.push("");
+  }
+  const inputFields = inputFieldsFor(spec);
+  let referencedTypeNames = [];
+  if (inputFields && inputFields.length > 0) {
+    const requiredFields = inputFields.filter((field) => field.required);
+    const optionalFields = inputFields.filter((field) => !field.required);
+    const ordered = [...requiredFields, ...optionalFields];
+    const maxFields = options.showAllFields ? ordered.length : 15;
+    const shown = ordered.slice(0, maxFields);
+    const fieldFlags = formatFieldFlags(shown);
+    lines.push(...(0, import_format.formatSection)("Input fields (via --set):", (0, import_format.formatFlags)({ flags: fieldFlags })));
+    const remaining = ordered.length - shown.length;
+    if (!options.showAllFields && remaining > 0) {
+      lines.push(
+        "",
+        `Additional fields (${remaining} more):`,
+        "  Run with --help-full or --help-all to see all fields.",
+        ""
+      );
+    } else {
+      lines.push("");
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const nestedTypes = collectNestedTypes(ordered, 2, visited);
+    if (options.showAllFields) {
+      if (nestedTypes.size > 0) {
+        lines.push(...renderTypeShapesSection(nestedTypes));
+        lines.push("");
+      }
+    } else {
+      referencedTypeNames = Array.from(nestedTypes.keys());
+    }
+  }
+  const optionalFlags = spec.flags ?? [];
+  if (optionalFlags.length > 0) {
+    lines.push(...(0, import_format.formatSection)("Flags:", (0, import_format.formatFlags)({ flags: optionalFlags })));
+    lines.push("");
+  }
+  const outputFlags = formatOutputFlags(spec);
+  if (outputFlags.length > 0) {
+    lines.push(...(0, import_format.formatSection)("Output flags:", (0, import_format.formatFlags)({ flags: outputFlags })));
+    lines.push("");
+  }
+  if (spec.notes && spec.notes.length > 0) {
+    lines.push("Notes:");
+    for (const note of spec.notes) lines.push(`  ${formatWithCommand(note, command)}`);
+    lines.push("");
+  }
+  if (spec.examples && spec.examples.length > 0) {
+    lines.push("Examples:");
+    for (const example of spec.examples) lines.push(`  ${formatWithCommand(example, command)}`);
+    lines.push("");
+  }
+  if (!options.showAllFields && referencedTypeNames.length > 0) {
+    const footerLines = formatTypeDetailsFooter(referencedTypeNames, command);
+    if (footerLines.length > 0) {
+      lines.push(...footerLines);
+      lines.push("");
+    }
+  }
+  return lines.join("\n").trimEnd();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderResourceHelp,
+  renderTopLevelHelp,
+  renderVerbHelp
+});
+//# sourceMappingURL=render.js.map

package/dist/cli/help/spec.d.ts

@@ -0,0 +1,39 @@
+export type FlagSpec = {
+    label: string;
+    description?: string;
+    required?: boolean;
+};
+export type OperationSpec = {
+    type: 'mutation' | 'query';
+    name: string;
+    inputArg?: string;
+};
+export type InputSpec = {
+    mode: 'set' | 'none';
+    arg?: string;
+    required?: boolean;
+};
+export type VerbOutputSpec = {
+    view?: boolean;
+    selection?: boolean;
+    pagination?: boolean;
+};
+export type VerbSpec = {
+    verb: string;
+    description?: string;
+    operation?: OperationSpec;
+    input?: InputSpec;
+    requiredFlags?: FlagSpec[];
+    flags?: FlagSpec[];
+    output?: VerbOutputSpec;
+    examples?: string[];
+    notes?: string[];
+};
+export type ResourceSpec = {
+    resource: string;
+    description?: string;
+    verbs: VerbSpec[];
+    flags?: FlagSpec[];
+    notes?: string[];
+    examples?: string[];
+};

package/dist/cli/help/spec.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 spec_exports = {};
+module.exports = __toCommonJS(spec_exports);
+//# sourceMappingURL=spec.js.map

package/dist/cli/input.d.ts

@@ -0,0 +1,9 @@
+export type BuiltInput = {
+    input: any;
+    used: boolean;
+};
+export declare const buildInput: ({ inputArg, setArgs, setJsonArgs, }: {
+    inputArg?: string;
+    setArgs?: string[];
+    setJsonArgs?: string[];
+}) => BuiltInput;

package/dist/cli/input.js

@@ -0,0 +1,104 @@
+"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 input_exports = {};
+__export(input_exports, {
+  buildInput: () => buildInput
+});
+module.exports = __toCommonJS(input_exports);
+var import_node_fs = require("node:fs");
+var import_errors = require("./errors");
+const readUtf8 = (path) => (0, import_node_fs.readFileSync)(path, "utf8");
+const parseJson = (value, label) => {
+  try {
+    return JSON.parse(value);
+  } catch (err) {
+    throw new import_errors.CliError(`${label} must be valid JSON: ${err.message}`, 2);
+  }
+};
+const parseJsonOrFile = (arg, label) => {
+  if (arg.startsWith("@file:")) return parseJson(readUtf8(arg.slice("@file:".length)), label);
+  if (arg.startsWith("@")) return parseJson(readUtf8(arg.slice(1)), label);
+  return parseJson(arg, label);
+};
+const parseSetValue = (raw) => {
+  if (raw.startsWith("@file:")) return readUtf8(raw.slice("@file:".length));
+  if (raw.startsWith("@json:")) return parseJson(readUtf8(raw.slice("@json:".length)), "--set-json");
+  const looksJson = raw.startsWith("{") || raw.startsWith("[") || raw.startsWith('"') || raw === "true" || raw === "false" || raw === "null" || /^-?\d+(\.\d+)?$/.test(raw);
+  if (looksJson) return parseJson(raw, "--set");
+  return raw;
+};
+const splitSetArg = (arg) => {
+  const eq = arg.indexOf("=");
+  if (eq === -1) throw new import_errors.CliError(`Expected --set path=value, got: ${arg}`, 2);
+  const path = arg.slice(0, eq).trim();
+  const value = arg.slice(eq + 1);
+  if (!path) throw new import_errors.CliError(`Expected --set path=value, got: ${arg}`, 2);
+  return { path, value };
+};
+const setDeep = (target, path, value) => {
+  const parts = path.split(".").filter(Boolean);
+  if (parts.length === 0) throw new import_errors.CliError(`Invalid --set path: ${path}`, 2);
+  let cursor = target;
+  for (let i = 0; i < parts.length; i++) {
+    const key = parts[i];
+    const isLast = i === parts.length - 1;
+    const nextKey = parts[i + 1];
+    const nextIsIndex = nextKey !== void 0 && /^\d+$/.test(nextKey);
+    if (isLast) {
+      if (Array.isArray(cursor) && /^\d+$/.test(key)) {
+        cursor[Number(key)] = value;
+      } else {
+        cursor[key] = value;
+      }
+      return;
+    }
+    if (Array.isArray(cursor) && /^\d+$/.test(key)) {
+      const idx = Number(key);
+      cursor[idx] ??= nextIsIndex ? [] : {};
+      cursor = cursor[idx];
+    } else {
+      cursor[key] ??= nextIsIndex ? [] : {};
+      cursor = cursor[key];
+    }
+  }
+};
+const buildInput = ({
+  inputArg,
+  setArgs,
+  setJsonArgs
+}) => {
+  const hasAny = Boolean(inputArg) || (setArgs?.length ?? 0) > 0 || (setJsonArgs?.length ?? 0) > 0;
+  if (!hasAny) return { input: void 0, used: false };
+  let result = inputArg ? parseJsonOrFile(inputArg, "--input") : {};
+  for (const arg of setArgs ?? []) {
+    const { path, value } = splitSetArg(arg);
+    setDeep(result, path, parseSetValue(value));
+  }
+  for (const arg of setJsonArgs ?? []) {
+    const { path, value } = splitSetArg(arg);
+    const parsed = parseJsonOrFile(value, "--set-json");
+    setDeep(result, path, parsed);
+  }
+  return { input: result, used: true };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildInput
+});
+//# sourceMappingURL=input.js.map

package/dist/cli/introspection/deprecations.d.ts

@@ -0,0 +1 @@
+export declare const isDeprecatedField: (typeName: string, fieldName: string) => boolean;

package/dist/cli/introspection/deprecations.js

@@ -0,0 +1,83 @@
+"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 deprecations_exports = {};
+__export(deprecations_exports, {
+  isDeprecatedField: () => isDeprecatedField
+});
+module.exports = __toCommonJS(deprecations_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_graphql = require("graphql");
+let cachedDeprecatedFieldMap;
+const schemaPath = (() => {
+  if (typeof __dirname === "string") {
+    return (0, import_node_path.resolve)(__dirname, "../../generated/admin-2026-04/schema.graphql");
+  }
+  const packageRoot = process.env.SHOP_CLI_PACKAGE_ROOT;
+  if (packageRoot) {
+    const distPath = (0, import_node_path.resolve)(packageRoot, "dist", "generated", "admin-2026-04", "schema.graphql");
+    if ((0, import_node_fs.existsSync)(distPath)) return distPath;
+    const srcPath = (0, import_node_path.resolve)(packageRoot, "src", "generated", "admin-2026-04", "schema.graphql");
+    if ((0, import_node_fs.existsSync)(srcPath)) return srcPath;
+  }
+  throw new Error("Unable to locate schema.graphql; set SHOP_CLI_PACKAGE_ROOT or run the compiled CLI");
+})();
+const hasDeprecatedDirective = (directives) => Array.isArray(directives) && directives.some((d) => d?.name?.value === "deprecated");
+const addDeprecatedFields = (map, typeName, fields) => {
+  if (!fields || fields.length === 0) return;
+  for (const f of fields) {
+    const fieldName = f?.name?.value;
+    if (!fieldName) continue;
+    if (!hasDeprecatedDirective(f.directives)) continue;
+    const set = map.get(typeName) ?? /* @__PURE__ */ new Set();
+    set.add(fieldName);
+    map.set(typeName, set);
+  }
+};
+const buildDeprecatedFieldMap = (doc) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const def of doc.definitions) {
+    if (def.kind === import_graphql.Kind.OBJECT_TYPE_DEFINITION || def.kind === import_graphql.Kind.OBJECT_TYPE_EXTENSION) {
+      addDeprecatedFields(map, def.name.value, def.fields);
+      continue;
+    }
+    if (def.kind === import_graphql.Kind.INTERFACE_TYPE_DEFINITION || def.kind === import_graphql.Kind.INTERFACE_TYPE_EXTENSION) {
+      addDeprecatedFields(map, def.name.value, def.fields);
+      continue;
+    }
+    if (def.kind === import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION || def.kind === import_graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
+      addDeprecatedFields(map, def.name.value, def.fields);
+      continue;
+    }
+  }
+  return map;
+};
+const getDeprecatedFieldMap = () => {
+  if (!cachedDeprecatedFieldMap) {
+    const sdl = (0, import_node_fs.readFileSync)(schemaPath, "utf8");
+    cachedDeprecatedFieldMap = buildDeprecatedFieldMap((0, import_graphql.parse)(sdl));
+  }
+  return cachedDeprecatedFieldMap;
+};
+const isDeprecatedField = (typeName, fieldName) => getDeprecatedFieldMap().get(typeName)?.has(fieldName) ?? false;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isDeprecatedField
+});
+//# sourceMappingURL=deprecations.js.map

package/dist/cli/introspection/format.d.ts

@@ -0,0 +1,6 @@
+import type { FieldInfo } from './index';
+export declare const printFieldsTable: ({ resource, typeName, fields, }: {
+    resource: string;
+    typeName: string;
+    fields: FieldInfo[];
+}) => void;