shop-cli 0.1.1

package/dist/cli/verbs/locations.js

@@ -0,0 +1,385 @@
+"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 locations_exports = {};
+__export(locations_exports, {
+  runLocations: () => runLocations
+});
+module.exports = __toCommonJS(locations_exports);
+var import_node_crypto = require("node:crypto");
+var import_errors = require("../errors");
+var import_gid = require("../gid");
+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 locationSummarySelection = {
+  id: true,
+  name: true,
+  address: {
+    address1: true,
+    city: true,
+    provinceCode: true,
+    countryCode: true,
+    zip: true
+  },
+  isActive: true,
+  fulfillsOnlineOrders: true,
+  hasActiveInventory: true,
+  localPickupSettingsV2: { instructions: true, pickupTime: true }
+};
+const locationFullSelection = {
+  ...locationSummarySelection,
+  address: {
+    address1: true,
+    address2: true,
+    city: true,
+    province: true,
+    provinceCode: true,
+    country: true,
+    countryCode: true,
+    zip: true,
+    phone: true,
+    formatted: true
+  },
+  fulfillmentService: { id: true, serviceName: true },
+  shipsInventory: true,
+  suggestedAddresses: { address1: true, city: true, zip: true }
+};
+const getLocationSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return locationFullSelection;
+  if (view === "raw") return {};
+  return locationSummarySelection;
+};
+const ensureObjectInput = (value, label) => {
+  if (value === null || typeof value !== "object") throw new import_errors.CliError(`${label} must be an object`, 2);
+  return value;
+};
+const maybeFailOnNamedUserErrors = (errors, ctx) => {
+  if (!Array.isArray(errors) || errors.length === 0) return;
+  (0, import_userErrors.maybeFailOnUserErrors)({ payload: { userErrors: errors }, failOnUserErrors: ctx.failOnUserErrors });
+};
+const parseCustomIdInput = ({
+  namespace,
+  key,
+  value
+}) => {
+  const customKey = typeof key === "string" ? key : void 0;
+  const customValue = typeof value === "string" ? value : void 0;
+  if (!customKey || !customValue) return void 0;
+  const ns = typeof namespace === "string" && namespace ? namespace : void 0;
+  return { ...ns ? { namespace: ns } : {}, key: customKey, value: customValue };
+};
+const runLocations = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop locations <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|count|update|delete",
+        "  by-identifier",
+        "  activate|deactivate|enable-local-pickup|disable-local-pickup",
+        "",
+        "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:",
+        "  --destination-location-id <gid|num>  (deactivate)",
+        "  --include-inactive                     (list)",
+        "  --include-legacy                       (list)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "by-identifier") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "custom-id-namespace": { type: "string" },
+        "custom-id-key": { type: "string" },
+        "custom-id-value": { type: "string" }
+      }
+    });
+    const idRaw = args.id;
+    const customId = parseCustomIdInput({
+      namespace: args["custom-id-namespace"],
+      key: args["custom-id-key"],
+      value: args["custom-id-value"]
+    });
+    if (!idRaw && !customId) throw new import_errors.CliError("Missing --id or --custom-id-key/--custom-id-value", 2);
+    const identifier = {
+      ...idRaw ? { id: (0, import_gid.coerceGid)(idRaw, "Location") } : {},
+      ...customId ? { customId } : {}
+    };
+    const selection = (0, import_select.resolveSelection)({
+      resource: "locations",
+      view: ctx.view,
+      baseSelection: getLocationSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      locationByIdentifier: {
+        __args: { identifier },
+        ...selection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.locationByIdentifier, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Location");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "locations",
+      view: ctx.view,
+      baseSelection: getLocationSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { location: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.location, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "include-inactive": { type: "boolean" },
+        "include-legacy": { type: "boolean" }
+      }
+    });
+    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 includeInactive = args["include-inactive"];
+    const includeLegacy = args["include-legacy"];
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "locations",
+      view: ctx.view,
+      baseSelection: getLocationSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      locations: {
+        __args: {
+          first,
+          after,
+          query,
+          reverse,
+          sortKey,
+          ...includeInactive ? { includeInactive } : {},
+          ...includeLegacy ? { includeLegacy } : {}
+        },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.locations,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)(
+        "locations",
+        { first, query, sort: sortKey, reverse },
+        [
+          ...includeInactive ? [{ flag: "--include-inactive", value: true }] : [],
+          ...includeLegacy ? [{ flag: "--include-legacy", value: true }] : []
+        ]
+      )
+    });
+    return;
+  }
+  if (verb === "count") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const query = args.query;
+    const result = await (0, import_router.runQuery)(ctx, { locationsCount: { __args: { query }, count: true, precision: true } });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.locationsCount?.count ?? "");
+    (0, import_output.printJson)(result.locationsCount, 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, {
+      locationAdd: {
+        __args: { input: built.input },
+        location: locationSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.locationAdd, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.locationAdd?.location?.id ?? "");
+    (0, import_output.printJson)(result.locationAdd, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Location");
+    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, {
+      locationEdit: {
+        __args: { id, input: built.input },
+        location: locationSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.locationEdit, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.locationEdit?.location?.id ?? "");
+    (0, import_output.printJson)(result.locationEdit, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Location");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      locationDelete: {
+        __args: { locationId: id },
+        deletedLocationId: true,
+        locationDeleteUserErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    maybeFailOnNamedUserErrors(result.locationDelete?.locationDeleteUserErrors, ctx);
+    if (ctx.quiet) return console.log(result.locationDelete?.deletedLocationId ?? "");
+    (0, import_output.printJson)(result.locationDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "activate") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Location");
+    const result = await (0, import_router.runMutation)(ctx, {
+      locationActivate: {
+        __directives: { idempotent: { key: (0, import_node_crypto.randomUUID)() } },
+        __args: { locationId: id },
+        location: locationSummarySelection,
+        locationActivateUserErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    maybeFailOnNamedUserErrors(result.locationActivate?.locationActivateUserErrors, ctx);
+    if (ctx.quiet) return console.log(result.locationActivate?.location?.id ?? "");
+    (0, import_output.printJson)(result.locationActivate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "deactivate") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "destination-location-id": { type: "string" } } });
+    const id = (0, import_shared.requireId)(args.id, "Location");
+    const destinationLocationId = args["destination-location-id"];
+    const result = await (0, import_router.runMutation)(ctx, {
+      locationDeactivate: {
+        __directives: { idempotent: { key: (0, import_node_crypto.randomUUID)() } },
+        __args: {
+          locationId: id,
+          ...destinationLocationId ? { destinationLocationId: (0, import_shared.requireId)(destinationLocationId, "Location") } : {}
+        },
+        location: locationSummarySelection,
+        locationDeactivateUserErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    maybeFailOnNamedUserErrors(result.locationDeactivate?.locationDeactivateUserErrors, ctx);
+    if (ctx.quiet) return console.log(result.locationDeactivate?.location?.id ?? "");
+    (0, import_output.printJson)(result.locationDeactivate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "enable-local-pickup") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Location");
+    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 input = ensureObjectInput(built.input, "Local pickup settings");
+    if (input.locationId === void 0) input.locationId = id;
+    if (!input.locationId) throw new import_errors.CliError("Missing locationId in --input/--set (or provide --id)", 2);
+    if (input.pickupTime === void 0) throw new import_errors.CliError("Missing pickupTime in --input/--set", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      locationLocalPickupEnable: {
+        __args: { localPickupSettings: input },
+        localPickupSettings: { instructions: true, pickupTime: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.locationLocalPickupEnable, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printJson)(result.locationLocalPickupEnable, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "disable-local-pickup") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Location");
+    const result = await (0, import_router.runMutation)(ctx, {
+      locationLocalPickupDisable: {
+        __args: { locationId: id },
+        locationId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.locationLocalPickupDisable, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.locationLocalPickupDisable?.locationId ?? "");
+    (0, import_output.printJson)(result.locationLocalPickupDisable, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for locations: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runLocations
+});
+//# sourceMappingURL=locations.js.map

package/dist/cli/verbs/market-localizations.d.ts

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

package/dist/cli/verbs/market-localizations.js

@@ -0,0 +1,291 @@
+"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 market_localizations_exports = {};
+__export(market_localizations_exports, {
+  runMarketLocalizations: () => runMarketLocalizations
+});
+module.exports = __toCommonJS(market_localizations_exports);
+var import_errors = require("../errors");
+var import_gid = require("../gid");
+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 marketLocalizationsSelection = (marketId) => ({
+  __args: { marketId },
+  key: true,
+  value: true,
+  outdated: true,
+  updatedAt: true,
+  market: { id: true, name: true, handle: true }
+});
+const marketLocalizableResourceSummarySelection = (marketId) => ({
+  resourceId: true,
+  marketLocalizableContent: { key: true, digest: true },
+  marketLocalizations: marketLocalizationsSelection(marketId)
+});
+const marketLocalizableResourceFullSelection = (marketId) => ({
+  ...marketLocalizableResourceSummarySelection(marketId),
+  marketLocalizableContent: { key: true, digest: true, value: true }
+});
+const getMarketLocalizableResourceSelection = (view, marketId) => {
+  if (view === "ids") return { resourceId: true };
+  if (view === "full") return marketLocalizableResourceFullSelection(marketId);
+  if (view === "raw") return {};
+  return marketLocalizableResourceSummarySelection(marketId);
+};
+const ensureResourceIdSelected = (selection) => {
+  if (!("resourceId" in selection)) selection.resourceId = true;
+  return selection;
+};
+const withSyntheticId = (node) => {
+  if (!node || typeof node !== "object") return node;
+  const resourceId = node.resourceId;
+  if (typeof resourceId === "string" && !("id" in node)) return { id: resourceId, ...node };
+  return node;
+};
+const extractArrayField = (input, field) => {
+  if (Array.isArray(input)) return input;
+  if (input && Array.isArray(input[field])) return input[field];
+  return void 0;
+};
+const parseMarketIds = (value) => {
+  const ids = (0, import_shared.parseStringList)(value, "--market-ids");
+  return ids.map((id) => (0, import_gid.coerceGid)(id, "Market"));
+};
+const runMarketLocalizations = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop market-localizations <verb> [flags]",
+        "",
+        "Verbs:",
+        "  localizable-resource|localizable-resources|localizable-resources-by-ids",
+        "  register|remove",
+        "",
+        "Notes:",
+        "  Market localizable resources are limited to resource types: METAOBJECT, METAFIELD.",
+        "  The marketLocalizations field requires --market-id.",
+        "",
+        "Common output flags:",
+        "  --view summary|ids|full|raw|all",
+        "  --format json|jsonl|table|markdown|raw",
+        "  --quiet",
+        "  --select <path>        (repeatable; dot paths; adds to base view selection)",
+        "  --selection <graphql>  (selection override; can be @file.gql)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "localizable-resource") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "resource-id": { type: "string" }, "market-id": { type: "string" } }
+    });
+    const resourceId = args["resource-id"];
+    if (!resourceId) throw new import_errors.CliError("Missing --resource-id", 2);
+    const marketIdRaw = args["market-id"];
+    if (!marketIdRaw) throw new import_errors.CliError("Missing --market-id", 2);
+    const marketId = (0, import_gid.coerceGid)(marketIdRaw, "Market");
+    const selection = ensureResourceIdSelected(
+      (0, import_select.resolveSelection)({
+        typeName: "MarketLocalizableResource",
+        view: ctx.view,
+        baseSelection: getMarketLocalizableResourceSelection(ctx.view, marketId),
+        select: args.select,
+        selection: args.selection,
+        include: args.include,
+        ensureId: false
+      })
+    );
+    const result = await (0, import_router.runQuery)(ctx, {
+      marketLocalizableResource: { __args: { resourceId }, ...selection }
+    });
+    if (result === void 0) return;
+    const node = result.marketLocalizableResource;
+    if (ctx.quiet) return (0, import_output.printIds)([node?.resourceId]);
+    (0, import_output.printNode)({ node: withSyntheticId(node), format: ctx.format, quiet: false });
+    return;
+  }
+  if (verb === "localizable-resources") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "resource-type": { type: "string" }, "market-id": { type: "string" } }
+    });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const resourceTypeRaw = args["resource-type"];
+    if (!resourceTypeRaw) throw new import_errors.CliError("Missing --resource-type", 2);
+    const resourceType = resourceTypeRaw.trim().toUpperCase();
+    const marketIdRaw = args["market-id"];
+    if (!marketIdRaw) throw new import_errors.CliError("Missing --market-id", 2);
+    const marketId = (0, import_gid.coerceGid)(marketIdRaw, "Market");
+    const nodeSelection = ensureResourceIdSelected(
+      (0, import_select.resolveSelection)({
+        typeName: "MarketLocalizableResource",
+        view: ctx.view,
+        baseSelection: getMarketLocalizableResourceSelection(ctx.view, marketId),
+        select: args.select,
+        selection: args.selection,
+        include: args.include,
+        ensureId: false
+      })
+    );
+    const result = await (0, import_router.runQuery)(ctx, {
+      marketLocalizableResources: {
+        __args: { first, after, reverse, resourceType },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    const nodes = (result.marketLocalizableResources?.nodes ?? []).map(withSyntheticId);
+    const connection = { ...result.marketLocalizableResources, nodes };
+    if (ctx.quiet) return (0, import_output.printIds)(nodes.map((n) => n?.id));
+    (0, import_output.printConnection)({
+      connection,
+      format: ctx.format,
+      quiet: false,
+      nextPageArgs: {
+        base: "shop market-localizations localizable-resources",
+        first,
+        reverse: reverse === true,
+        extraFlags: [{ flag: "--resource-type", value: resourceType }]
+      }
+    });
+    return;
+  }
+  if (verb === "localizable-resources-by-ids") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "resource-ids": { type: "string", multiple: true }, "market-id": { type: "string" } }
+    });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const resourceIds = (0, import_shared.parseStringList)(args["resource-ids"], "--resource-ids");
+    const marketIdRaw = args["market-id"];
+    if (!marketIdRaw) throw new import_errors.CliError("Missing --market-id", 2);
+    const marketId = (0, import_gid.coerceGid)(marketIdRaw, "Market");
+    const nodeSelection = ensureResourceIdSelected(
+      (0, import_select.resolveSelection)({
+        typeName: "MarketLocalizableResource",
+        view: ctx.view,
+        baseSelection: getMarketLocalizableResourceSelection(ctx.view, marketId),
+        select: args.select,
+        selection: args.selection,
+        include: args.include,
+        ensureId: false
+      })
+    );
+    const result = await (0, import_router.runQuery)(ctx, {
+      marketLocalizableResourcesByIds: {
+        __args: { first, after, reverse, resourceIds },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    const nodes = (result.marketLocalizableResourcesByIds?.nodes ?? []).map(withSyntheticId);
+    const connection = { ...result.marketLocalizableResourcesByIds, nodes };
+    if (ctx.quiet) return (0, import_output.printIds)(nodes.map((n) => n?.id));
+    (0, import_output.printConnection)({
+      connection,
+      format: ctx.format,
+      quiet: false,
+      nextPageArgs: {
+        base: "shop market-localizations localizable-resources-by-ids",
+        first,
+        reverse: reverse === true,
+        extraFlags: resourceIds.map((id) => ({ flag: "--resource-ids", value: id }))
+      }
+    });
+    return;
+  }
+  if (verb === "register") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "resource-id": { type: "string" } } });
+    const resourceId = args["resource-id"];
+    if (!resourceId) throw new import_errors.CliError("Missing --resource-id", 2);
+    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 marketLocalizations = extractArrayField(built.input, "marketLocalizations");
+    if (!marketLocalizations || marketLocalizations.length === 0) {
+      throw new import_errors.CliError("Missing marketLocalizations array (use --input [...] or --set marketLocalizations[0].*)", 2);
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      marketLocalizationsRegister: {
+        __args: { resourceId, marketLocalizations },
+        marketLocalizations: { key: true, value: true, market: { id: true, name: true } },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.marketLocalizationsRegister,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return;
+    (0, import_output.printJson)(result.marketLocalizationsRegister, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "remove") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "resource-id": { type: "string" },
+        "market-ids": { type: "string", multiple: true },
+        keys: { type: "string" }
+      }
+    });
+    const resourceId = args["resource-id"];
+    if (!resourceId) throw new import_errors.CliError("Missing --resource-id", 2);
+    const marketIds = parseMarketIds(args["market-ids"]);
+    const marketLocalizationKeys = (0, import_shared.parseCsv)(args.keys, "--keys");
+    const result = await (0, import_router.runMutation)(ctx, {
+      marketLocalizationsRemove: {
+        __args: { resourceId, marketIds, marketLocalizationKeys },
+        marketLocalizations: { key: true, value: true, market: { id: true, name: true } },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.marketLocalizationsRemove, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return;
+    (0, import_output.printJson)(result.marketLocalizationsRemove, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for market-localizations: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runMarketLocalizations
+});
+//# sourceMappingURL=market-localizations.js.map

package/dist/cli/verbs/market-web-presences.d.ts

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