shop-cli 0.1.1

package/dist/cli/verbs/metafield-definition-tools.js

@@ -0,0 +1,289 @@
+"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 metafield_definition_tools_exports = {};
+__export(metafield_definition_tools_exports, {
+  runMetafieldDefinitionTools: () => runMetafieldDefinitionTools
+});
+module.exports = __toCommonJS(metafield_definition_tools_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 metafieldDefinitionSummarySelection = {
+  id: true,
+  name: true,
+  namespace: true,
+  key: true,
+  ownerType: true,
+  type: { name: true, category: true }
+};
+const getMetafieldDefinitionSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "raw") return {};
+  return metafieldDefinitionSummarySelection;
+};
+const metafieldDefinitionTypeSelection = {
+  name: true,
+  category: true,
+  valueType: true,
+  supportedValidations: { name: true, type: true },
+  supportsDefinitionMigrations: true
+};
+const standardTemplateSummarySelection = {
+  id: true,
+  name: true,
+  namespace: true,
+  key: true,
+  type: { name: true, category: true },
+  ownerTypes: true,
+  visibleToStorefrontApi: true
+};
+const getStandardTemplateSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "raw") return {};
+  return standardTemplateSummarySelection;
+};
+const buildMetafieldDefinitionIdentifier = ({
+  ownerType,
+  key,
+  namespace
+}) => {
+  const ot = typeof ownerType === "string" ? ownerType : void 0;
+  const k = typeof key === "string" ? key : void 0;
+  const ns = typeof namespace === "string" ? namespace : void 0;
+  if (!ot) throw new import_errors.CliError("Missing --owner-type", 2);
+  if (!k) throw new import_errors.CliError("Missing --key", 2);
+  return { ownerType: ot, key: k, ...ns ? { namespace: ns } : {} };
+};
+const runMetafieldDefinitionTools = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop metafield-definition-tools <verb> [flags]",
+        "",
+        "Verbs:",
+        "  types|pin|unpin|update",
+        "  standard-templates|standard-enable",
+        "",
+        "Common output flags:",
+        "  --format json|jsonl|table|markdown|raw",
+        "  --quiet               (IDs only when possible)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "types") {
+    const result = await (0, import_router.runQuery)(ctx, { metafieldDefinitionTypes: metafieldDefinitionTypeSelection });
+    if (result === void 0) return;
+    if (ctx.quiet) return;
+    (0, import_output.printJson)(result.metafieldDefinitionTypes, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "pin" || verb === "unpin") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "definition-id": { type: "string" } } });
+    const definitionIdRaw = args["definition-id"] ?? args.id;
+    const identifier = definitionIdRaw ? void 0 : buildMetafieldDefinitionIdentifier({
+      ownerType: args["owner-type"],
+      key: args.key,
+      namespace: args.namespace
+    });
+    const definitionId = definitionIdRaw ? (0, import_shared.requireId)(definitionIdRaw, "MetafieldDefinition") : void 0;
+    const mutation = verb === "pin" ? "metafieldDefinitionPin" : "metafieldDefinitionUnpin";
+    const result = await (0, import_router.runMutation)(ctx, {
+      [mutation]: {
+        __args: { ...definitionId ? { definitionId } : {}, ...identifier ? { identifier } : {} },
+        ...verb === "pin" ? { pinnedDefinition: metafieldDefinitionSummarySelection } : { unpinnedDefinition: metafieldDefinitionSummarySelection },
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    const payload = result[mutation];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      const node = payload?.pinnedDefinition ?? payload?.unpinnedDefinition;
+      return console.log(node?.id ?? "");
+    }
+    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        key: { type: "string" },
+        namespace: { type: "string" },
+        "owner-type": { type: "string" }
+      }
+    });
+    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 identifier = buildMetafieldDefinitionIdentifier({
+      ownerType: args["owner-type"] ?? built.input?.ownerType,
+      key: args.key ?? built.input?.key,
+      namespace: args.namespace ?? built.input?.namespace
+    });
+    const definition = {
+      ...built.input,
+      ownerType: identifier.ownerType,
+      key: identifier.key,
+      ...identifier.namespace ? { namespace: identifier.namespace } : {}
+    };
+    const result = await (0, import_router.runMutation)(ctx, {
+      metafieldDefinitionUpdate: {
+        __args: { definition },
+        updatedDefinition: metafieldDefinitionSummarySelection,
+        userErrors: { field: true, message: true, code: true },
+        validationJob: { id: true, done: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.metafieldDefinitionUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.metafieldDefinitionUpdate?.updatedDefinition?.id ?? "");
+    (0, import_output.printJson)(result.metafieldDefinitionUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "standard-templates") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "constraint-subtype": { type: "string" },
+        "constraint-status": { type: "string" },
+        "exclude-activated": { type: "boolean" }
+      }
+    });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const constraintSubtype = args["constraint-subtype"];
+    const constraintStatus = args["constraint-status"];
+    const excludeActivated = args["exclude-activated"];
+    const nodeSelection = (0, import_select.resolveSelection)({
+      typeName: "StandardMetafieldDefinitionTemplate",
+      view: ctx.view,
+      baseSelection: getStandardTemplateSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      standardMetafieldDefinitionTemplates: {
+        __args: {
+          ...constraintSubtype ? { constraintSubtype } : {},
+          ...constraintStatus ? { constraintStatus } : {},
+          ...excludeActivated === void 0 ? {} : { excludeActivated },
+          first,
+          after,
+          reverse
+        },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.standardMetafieldDefinitionTemplates,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: {
+        base: "shop metafield-definition-tools standard-templates",
+        first,
+        reverse: reverse === true,
+        extraFlags: [
+          ...constraintSubtype ? [{ flag: "--constraint-subtype", value: constraintSubtype }] : [],
+          ...constraintStatus ? [{ flag: "--constraint-status", value: constraintStatus }] : [],
+          ...excludeActivated === true ? [{ flag: "--exclude-activated", value: true }] : []
+        ]
+      }
+    });
+    return;
+  }
+  if (verb === "standard-enable") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        id: { type: "string" },
+        namespace: { type: "string" },
+        key: { type: "string" },
+        "owner-type": { type: "string" },
+        pin: { type: "boolean" },
+        "visible-to-storefront-api": { type: "boolean" },
+        "use-as-collection-condition": { type: "boolean" }
+      }
+    });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = built.used ? built.input : {};
+    const ownerType = args["owner-type"] ?? input.ownerType;
+    if (!ownerType) throw new import_errors.CliError("Missing --owner-type", 2);
+    const id = args.id ?? input.id;
+    const namespace = args.namespace ?? input.namespace;
+    const key = args.key ?? input.key;
+    const pin = args.pin ?? input.pin;
+    const visibleToStorefrontApi = args["visible-to-storefront-api"] ?? input.visibleToStorefrontApi;
+    const useAsCollectionCondition = args["use-as-collection-condition"] ?? input.useAsCollectionCondition;
+    const capabilities = input.capabilities;
+    const access = input.access;
+    const result = await (0, import_router.runMutation)(ctx, {
+      standardMetafieldDefinitionEnable: {
+        __args: {
+          ownerType,
+          ...id ? { id } : {},
+          ...namespace ? { namespace } : {},
+          ...key ? { key } : {},
+          ...pin === void 0 ? {} : { pin },
+          ...visibleToStorefrontApi === void 0 ? {} : { visibleToStorefrontApi },
+          ...useAsCollectionCondition === void 0 ? {} : { useAsCollectionCondition },
+          ...capabilities ? { capabilities } : {},
+          ...access ? { access } : {}
+        },
+        createdDefinition: metafieldDefinitionSummarySelection,
+        userErrors: { field: true, message: true, code: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.standardMetafieldDefinitionEnable,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.standardMetafieldDefinitionEnable?.createdDefinition?.id ?? "");
+    (0, import_output.printJson)(result.standardMetafieldDefinitionEnable, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for metafield-definition-tools: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runMetafieldDefinitionTools
+});
+//# sourceMappingURL=metafield-definition-tools.js.map

package/dist/cli/verbs/metafield-definitions.d.ts

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

package/dist/cli/verbs/metafield-definitions.js

@@ -0,0 +1,240 @@
+"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 metafield_definitions_exports = {};
+__export(metafield_definitions_exports, {
+  runMetafieldDefinitions: () => runMetafieldDefinitions
+});
+module.exports = __toCommonJS(metafield_definitions_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 metafieldDefinitionSummarySelection = {
+  id: true,
+  name: true,
+  namespace: true,
+  key: true,
+  ownerType: true,
+  type: { name: true, category: true }
+};
+const metafieldDefinitionFullSelection = {
+  ...metafieldDefinitionSummarySelection
+};
+const getMetafieldDefinitionSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return metafieldDefinitionFullSelection;
+  if (view === "raw") return {};
+  return metafieldDefinitionSummarySelection;
+};
+const runMetafieldDefinitions = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop metafield-definitions <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|update|delete",
+        "",
+        "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)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "MetafieldDefinition");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "metafield-definitions",
+      view: ctx.view,
+      baseSelection: getMetafieldDefinitionSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { metafieldDefinition: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.metafieldDefinition, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "owner-type": { type: "string" } }
+    });
+    const ownerType = args["owner-type"];
+    if (!ownerType) throw new import_errors.CliError("Missing --owner-type (e.g. PRODUCT)", 2);
+    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: "metafield-definitions",
+      view: ctx.view,
+      baseSelection: getMetafieldDefinitionSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      metafieldDefinitions: {
+        __args: { ownerType, first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.metafieldDefinitions,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("metafield-definitions", { first, query, sort: sortKey, reverse })
+    });
+    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, {
+      metafieldDefinitionCreate: {
+        __args: { definition: built.input },
+        createdDefinition: metafieldDefinitionSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.metafieldDefinitionCreate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.metafieldDefinitionCreate?.createdDefinition?.id ?? "");
+    (0, import_output.printJson)(result.metafieldDefinitionCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { key: { type: "string" }, namespace: { type: "string" }, "owner-type": { type: "string" } }
+    });
+    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);
+    let key = args.key;
+    let namespace = args.namespace;
+    let ownerType = args["owner-type"];
+    const id = args.id;
+    if (id) {
+      const resolved = await (0, import_router.runQuery)(ctx, {
+        metafieldDefinition: {
+          __args: { id: (0, import_shared.requireId)(id, "MetafieldDefinition") },
+          key: true,
+          namespace: true,
+          ownerType: true
+        }
+      });
+      if (resolved === void 0) return;
+      if (!resolved.metafieldDefinition) throw new import_errors.CliError("MetafieldDefinition not found for --id", 2);
+      key = resolved.metafieldDefinition.key;
+      namespace = resolved.metafieldDefinition.namespace;
+      ownerType = resolved.metafieldDefinition.ownerType;
+    }
+    key ??= built.input?.key;
+    namespace ??= built.input?.namespace;
+    ownerType ??= built.input?.ownerType;
+    if (!key) throw new import_errors.CliError("Missing identifier key (pass --key, or include key in --input, or pass --id)", 2);
+    if (!ownerType) {
+      throw new import_errors.CliError("Missing identifier ownerType (pass --owner-type, or include ownerType in --input, or pass --id)", 2);
+    }
+    const definition = {
+      ...built.input,
+      key,
+      ownerType,
+      ...namespace === void 0 ? {} : { namespace }
+    };
+    const result = await (0, import_router.runMutation)(ctx, {
+      metafieldDefinitionUpdate: {
+        __args: { definition },
+        updatedDefinition: metafieldDefinitionSummarySelection,
+        userErrors: { field: true, message: true },
+        validationJob: { id: true, done: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.metafieldDefinitionUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.metafieldDefinitionUpdate?.updatedDefinition?.id ?? "");
+    (0, import_output.printJson)(result.metafieldDefinitionUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "MetafieldDefinition");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const extra = (0, import_input.buildInput)({
+      inputArg: void 0,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      metafieldDefinitionDelete: {
+        __args: { id, ...extra.used ? extra.input : {} },
+        deletedDefinitionId: true,
+        deletedDefinition: { namespace: true, key: true, ownerType: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.metafieldDefinitionDelete,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.metafieldDefinitionDelete?.deletedDefinitionId ?? "");
+    (0, import_output.printJson)(result.metafieldDefinitionDelete, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for metafield-definitions: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runMetafieldDefinitions
+});
+//# sourceMappingURL=metafield-definitions.js.map

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

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

package/dist/cli/verbs/metafields.js

@@ -0,0 +1,112 @@
+"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 metafields_exports = {};
+__export(metafields_exports, {
+  runMetafields: () => runMetafields
+});
+module.exports = __toCommonJS(metafields_exports);
+var import_errors = require("../errors");
+var import_input = require("../input");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_userErrors = require("../userErrors");
+const asArray = (value) => {
+  if (Array.isArray(value)) return value;
+  if (value && typeof value === "object") return [value];
+  return [];
+};
+const requireOwnerId = (value) => {
+  if (typeof value !== "string" || !value) throw new import_errors.CliError("Missing --owner-id", 2);
+  return value;
+};
+const runMetafields = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop metafields <verb> [flags]",
+        "",
+        "Verbs:",
+        "  delete"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "owner-id": { type: "string" },
+        namespace: { type: "string" },
+        key: { type: "string" }
+      }
+    });
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const fromInput = built.used ? asArray(built.input) : [];
+    const ownerIdRaw = args["owner-id"] ?? args.id;
+    const namespace = args.namespace;
+    const key = args.key;
+    const fromFlags = fromInput.length > 0 ? [] : [
+      {
+        ownerId: requireOwnerId(ownerIdRaw),
+        namespace: namespace ?? (() => {
+          throw new import_errors.CliError("Missing --namespace", 2);
+        })(),
+        key: key ?? (() => {
+          throw new import_errors.CliError("Missing --key", 2);
+        })()
+      }
+    ];
+    const metafields = fromInput.length > 0 ? fromInput : fromFlags;
+    const result = await (0, import_router.runMutation)(ctx, {
+      metafieldsDelete: {
+        __args: { metafields },
+        deletedMetafields: { ownerId: true, namespace: true, key: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.metafieldsDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      (0, import_output.printIds)(
+        (result.metafieldsDelete?.deletedMetafields ?? []).map(
+          (m) => m?.ownerId && m?.namespace && m?.key ? `${m.ownerId}:${m.namespace}:${m.key}` : void 0
+        )
+      );
+      return;
+    }
+    (0, import_output.printJson)(result.metafieldsDelete, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for metafields: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runMetafields
+});
+//# sourceMappingURL=metafields.js.map

package/dist/cli/verbs/metaobject-definition-tools.d.ts

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