shop-cli 0.1.1

package/dist/cli/verbs/types.js

@@ -0,0 +1,224 @@
+"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 types_exports = {};
+__export(types_exports, {
+  runTypes: () => runTypes
+});
+module.exports = __toCommonJS(types_exports);
+var import_node_util = require("node:util");
+var import_errors = require("../errors");
+var import_schema_help = require("../../generated/help/schema-help");
+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 printHelp = () => {
+  const command = (0, import_command.resolveCliCommand)();
+  console.log(
+    [
+      "Explore input types and enums from the Shopify Admin API schema.",
+      "",
+      "Usage:",
+      `  ${command} types <TypeName>`,
+      "",
+      "Arguments:",
+      "  TypeName    The name of an input type or enum to explore.",
+      "",
+      "Flags:",
+      "  --all       Show all enum values (for large enums).",
+      "",
+      "Examples:",
+      `  ${command} types ProductBundleComponentInput`,
+      `  ${command} types ProductStatus`,
+      `  ${command} types CountryCode --all`
+    ].join("\n")
+  );
+};
+const fuzzyMatch = (needle, haystack) => {
+  const lowerNeedle = needle.toLowerCase();
+  const lowerHaystack = haystack.toLowerCase();
+  let ni = 0;
+  for (let hi = 0; hi < lowerHaystack.length && ni < lowerNeedle.length; hi++) {
+    if (lowerHaystack[hi] === lowerNeedle[ni]) ni++;
+  }
+  return ni === lowerNeedle.length;
+};
+const scoreMatch = (query, typeName) => {
+  const lowerQuery = query.toLowerCase();
+  const lowerType = typeName.toLowerCase();
+  if (lowerType === lowerQuery) return 0;
+  if (lowerType.startsWith(lowerQuery)) return 1;
+  if (lowerType.includes(lowerQuery)) return 2;
+  if (fuzzyMatch(query, typeName)) return 3;
+  return Infinity;
+};
+const findSuggestions = (query, limit = 5) => {
+  const allTypes = [
+    ...Object.keys(import_schema_help.inputTypeHelp),
+    ...Object.keys(import_schema_help.enumTypeHelp)
+  ];
+  const scored = allTypes.map((name) => ({ name, score: scoreMatch(query, name) })).filter(({ score }) => score < Infinity).sort((a, b) => a.score - b.score || a.name.localeCompare(b.name)).slice(0, limit);
+  return scored.map(({ name }) => name);
+};
+const formatFieldType = (field) => {
+  let label = field.typeName;
+  if (field.isList) label = `${label}[]`;
+  if (field.required) label = `${label}!`;
+  return label;
+};
+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 (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 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 formatFieldLine = (field, nameWidth, typeWidth, lineIndent, totalWidth = 108) => {
+  const name = field.name.padEnd(nameWidth);
+  const type = formatFieldType(field).padEnd(typeWidth);
+  const required = field.required ? "Required. " : "";
+  const desc = field.description ?? "";
+  const prefix = `${lineIndent}${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);
+  const lines = [`${prefix}${wrappedLines[0]}`];
+  for (let i = 1; i < wrappedLines.length; i++) {
+    lines.push(`${indent}${wrappedLines[i]}`);
+  }
+  return lines.join("\n");
+};
+const renderInputType = (typeName, fields, showAll) => {
+  const lines = [typeName, "", "Fields:"];
+  const nameWidth = Math.max(...fields.map((f) => f.name.length), 4);
+  const typeWidth = Math.max(...fields.map((f) => formatFieldType(f).length), 4);
+  for (const field of fields) {
+    lines.push(formatFieldLine(field, nameWidth, typeWidth, "  "));
+  }
+  const visited = /* @__PURE__ */ new Set([typeName]);
+  const nested = collectNestedTypes(fields, 2, visited);
+  for (const [nestedName, nestedFields] of nested) {
+    lines.push("");
+    lines.push(`Type: ${nestedName}`);
+    const nestedNameWidth = Math.max(...nestedFields.map((f) => f.name.length), 4);
+    const nestedTypeWidth = Math.max(...nestedFields.map((f) => formatFieldType(f).length), 4);
+    for (const field of nestedFields) {
+      lines.push(formatFieldLine(field, nestedNameWidth, nestedTypeWidth, "  "));
+    }
+  }
+  return lines.join("\n");
+};
+const renderEnumType = (typeName, values, showAll) => {
+  const lines = [typeName, ""];
+  const MAX_INLINE = 10;
+  const MAX_EXPANDED = 20;
+  if (!showAll && values.length > MAX_EXPANDED) {
+    const shown = values.slice(0, MAX_INLINE).map((v) => v.name);
+    const remaining = values.length - MAX_INLINE;
+    lines.push(`Values: ${shown.join(" | ")} | ... and ${remaining} more`);
+    lines.push("");
+    lines.push("Use --all to see all values.");
+  } else {
+    lines.push("Values:");
+    const nameWidth = Math.max(...values.map((v) => v.name.length), 4);
+    for (const value of values) {
+      const name = value.name.padEnd(nameWidth);
+      const desc = value.description ?? "";
+      const deprecated = value.deprecated ? value.deprecationReason ? `[Deprecated: ${value.deprecationReason}] ` : "[Deprecated] " : "";
+      lines.push(`  ${name}  ${deprecated}${desc}`);
+    }
+  }
+  return lines.join("\n");
+};
+const runTypes = async ({
+  verb,
+  argv
+}) => {
+  if (verb === "help") {
+    printHelp();
+    return;
+  }
+  if (argv.includes("--help") || argv.includes("-h") || !verb) {
+    printHelp();
+    return;
+  }
+  const parsed = (0, import_node_util.parseArgs)({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      all: { type: "boolean" },
+      help: { type: "boolean" },
+      h: { type: "boolean" }
+    }
+  });
+  const showAll = parsed.values.all ?? false;
+  const typeName = verb;
+  const inputFields = import_schema_help.inputTypeHelp[typeName];
+  if (inputFields) {
+    console.log(renderInputType(typeName, inputFields, showAll));
+    return;
+  }
+  const enumValues = import_schema_help.enumTypeHelp[typeName];
+  if (enumValues) {
+    console.log(renderEnumType(typeName, enumValues, showAll));
+    return;
+  }
+  const suggestions = findSuggestions(typeName);
+  const lines = [`Type "${typeName}" not found.`];
+  if (suggestions.length > 0) {
+    lines.push("");
+    lines.push("Did you mean?");
+    for (const suggestion of suggestions) {
+      lines.push(`  ${suggestion}`);
+    }
+  }
+  throw new import_errors.CliError(lines.join("\n"), 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runTypes
+});
+//# sourceMappingURL=types.js.map

package/dist/cli/verbs/url-redirects.d.ts

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

package/dist/cli/verbs/url-redirects.js

@@ -0,0 +1,465 @@
+"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 url_redirects_exports = {};
+__export(url_redirects_exports, {
+  runUrlRedirects: () => runUrlRedirects
+});
+module.exports = __toCommonJS(url_redirects_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 urlRedirectSummarySelection = {
+  id: true,
+  path: true,
+  target: true
+};
+const urlRedirectFullSelection = {
+  ...urlRedirectSummarySelection
+};
+const getUrlRedirectSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return urlRedirectFullSelection;
+  if (view === "raw") return {};
+  return urlRedirectSummarySelection;
+};
+const savedSearchSummarySelection = {
+  id: true,
+  name: true,
+  query: true
+};
+const getSavedSearchSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "raw") return {};
+  return savedSearchSummarySelection;
+};
+const urlRedirectImportSummarySelection = {
+  id: true,
+  finished: true,
+  count: true,
+  createdCount: true,
+  updatedCount: true,
+  failedCount: true
+};
+const urlRedirectImportFullSelection = {
+  ...urlRedirectImportSummarySelection,
+  finishedAt: true,
+  previewRedirects: { path: true, target: true }
+};
+const getUrlRedirectImportSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return urlRedirectImportFullSelection;
+  if (view === "raw") return {};
+  return urlRedirectImportSummarySelection;
+};
+const runUrlRedirects = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop url-redirects <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|count|saved-searches|update|delete",
+        "  import-create|import-submit|import-get",
+        "  bulk-delete-all|bulk-delete-ids|bulk-delete-saved-search|bulk-delete-search",
+        "",
+        "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 === "count") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { limit: { type: "string" }, "saved-search-id": { type: "string" } }
+    });
+    const query = args.query;
+    const limitRaw = args.limit;
+    const savedSearchIdRaw = args["saved-search-id"];
+    const limit = limitRaw === void 0 || limitRaw === null || limitRaw === "" ? void 0 : Number(limitRaw);
+    if (limit !== void 0 && (!Number.isFinite(limit) || limit <= 0)) {
+      throw new import_errors.CliError("--limit must be a positive number", 2);
+    }
+    const savedSearchId = savedSearchIdRaw ? (0, import_gid.coerceGid)(String(savedSearchIdRaw), "SavedSearch") : void 0;
+    const result = await (0, import_router.runQuery)(ctx, {
+      urlRedirectsCount: {
+        __args: {
+          ...query ? { query } : {},
+          ...savedSearchId ? { savedSearchId } : {},
+          ...limit !== void 0 ? { limit: Math.floor(limit) } : {}
+        },
+        count: true,
+        precision: true
+      }
+    });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.urlRedirectsCount?.count ?? "");
+    (0, import_output.printJson)(result.urlRedirectsCount, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "saved-searches") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      typeName: "SavedSearch",
+      view: ctx.view,
+      baseSelection: getSavedSearchSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      urlRedirectSavedSearches: {
+        __args: { first, after, reverse },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.urlRedirectSavedSearches,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: { base: "shop url-redirects saved-searches", first, reverse: reverse === true }
+    });
+    return;
+  }
+  if (verb === "import-create") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { url: { type: "string" } } });
+    const url = args.url;
+    if (!url) throw new import_errors.CliError("Missing --url", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      urlRedirectImportCreate: {
+        __args: { url },
+        urlRedirectImport: {
+          id: true,
+          finished: true,
+          count: true,
+          createdCount: true,
+          updatedCount: true,
+          failedCount: true,
+          finishedAt: true,
+          previewRedirects: { path: true, target: true }
+        },
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.urlRedirectImportCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.urlRedirectImportCreate?.urlRedirectImport?.id ?? "");
+    (0, import_output.printJson)(result.urlRedirectImportCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "import-submit") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "UrlRedirectImport");
+    const result = await (0, import_router.runMutation)(ctx, {
+      urlRedirectImportSubmit: {
+        __args: { id },
+        job: { id: true, done: true },
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.urlRedirectImportSubmit, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(id ?? "");
+    const selection = (0, import_select.resolveSelection)({
+      typeName: "UrlRedirectImport",
+      view: ctx.view,
+      baseSelection: getUrlRedirectImportSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: true
+    });
+    const importResult = await (0, import_router.runQuery)(ctx, { urlRedirectImport: { __args: { id }, ...selection } });
+    if (importResult === void 0) return;
+    (0, import_output.printJson)(
+      {
+        urlRedirectImport: importResult.urlRedirectImport ?? null,
+        job: result.urlRedirectImportSubmit?.job ?? null,
+        userErrors: result.urlRedirectImportSubmit?.userErrors ?? []
+      },
+      ctx.format !== "raw"
+    );
+    return;
+  }
+  if (verb === "import-get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "UrlRedirectImport");
+    const selection = (0, import_select.resolveSelection)({
+      typeName: "UrlRedirectImport",
+      view: ctx.view,
+      baseSelection: getUrlRedirectImportSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { urlRedirectImport: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.urlRedirectImport, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "bulk-delete-all" || verb === "bulk-delete-ids" || verb === "bulk-delete-saved-search" || verb === "bulk-delete-search") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "saved-search-id": { type: "string" },
+        search: { type: "string" }
+      }
+    });
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    if (verb === "bulk-delete-all") {
+      const countResult2 = await (0, import_router.runQuery)(ctx, {
+        urlRedirectsCount: { count: true, precision: true }
+      });
+      const result2 = await (0, import_router.runMutation)(ctx, {
+        urlRedirectBulkDeleteAll: {
+          job: { id: true, done: true },
+          userErrors: { field: true, message: true }
+        }
+      });
+      if (result2 === void 0) return;
+      (0, import_userErrors.maybeFailOnUserErrors)({ payload: result2.urlRedirectBulkDeleteAll, failOnUserErrors: ctx.failOnUserErrors });
+      if (ctx.quiet) return console.log(result2.urlRedirectBulkDeleteAll?.job?.id ?? "");
+      (0, import_output.printJson)(
+        {
+          job: result2.urlRedirectBulkDeleteAll?.job ?? null,
+          count: countResult2?.urlRedirectsCount ?? null,
+          userErrors: result2.urlRedirectBulkDeleteAll?.userErrors ?? []
+        },
+        ctx.format !== "raw"
+      );
+      return;
+    }
+    if (verb === "bulk-delete-ids") {
+      const ids = (0, import_shared.parseIds)(args.ids, "UrlRedirect");
+      const result2 = await (0, import_router.runMutation)(ctx, {
+        urlRedirectBulkDeleteByIds: {
+          __args: { ids },
+          job: { id: true, done: true },
+          userErrors: { code: true, field: true, message: true }
+        }
+      });
+      if (result2 === void 0) return;
+      (0, import_userErrors.maybeFailOnUserErrors)({ payload: result2.urlRedirectBulkDeleteByIds, failOnUserErrors: ctx.failOnUserErrors });
+      if (ctx.quiet) return console.log(result2.urlRedirectBulkDeleteByIds?.job?.id ?? "");
+      (0, import_output.printJson)(
+        {
+          job: result2.urlRedirectBulkDeleteByIds?.job ?? null,
+          requestedIds: ids,
+          requestedCount: ids.length,
+          userErrors: result2.urlRedirectBulkDeleteByIds?.userErrors ?? []
+        },
+        ctx.format !== "raw"
+      );
+      return;
+    }
+    if (verb === "bulk-delete-saved-search") {
+      const raw = args["saved-search-id"];
+      if (!raw) throw new import_errors.CliError("Missing --saved-search-id", 2);
+      const savedSearchId = (0, import_gid.coerceGid)(raw, "SavedSearch");
+      const countResult2 = await (0, import_router.runQuery)(ctx, {
+        urlRedirectsCount: { __args: { savedSearchId }, count: true, precision: true }
+      });
+      const result2 = await (0, import_router.runMutation)(ctx, {
+        urlRedirectBulkDeleteBySavedSearch: {
+          __args: { savedSearchId },
+          job: { id: true, done: true },
+          userErrors: { code: true, field: true, message: true }
+        }
+      });
+      if (result2 === void 0) return;
+      (0, import_userErrors.maybeFailOnUserErrors)({
+        payload: result2.urlRedirectBulkDeleteBySavedSearch,
+        failOnUserErrors: ctx.failOnUserErrors
+      });
+      if (ctx.quiet) return console.log(result2.urlRedirectBulkDeleteBySavedSearch?.job?.id ?? "");
+      (0, import_output.printJson)(
+        {
+          job: result2.urlRedirectBulkDeleteBySavedSearch?.job ?? null,
+          count: countResult2?.urlRedirectsCount ?? null,
+          savedSearchId,
+          userErrors: result2.urlRedirectBulkDeleteBySavedSearch?.userErrors ?? []
+        },
+        ctx.format !== "raw"
+      );
+      return;
+    }
+    const search = args.search;
+    if (!search) throw new import_errors.CliError("Missing --search", 2);
+    const countResult = await (0, import_router.runQuery)(ctx, {
+      urlRedirectsCount: { __args: { query: search }, count: true, precision: true }
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      urlRedirectBulkDeleteBySearch: {
+        __args: { search },
+        job: { id: true, done: true },
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.urlRedirectBulkDeleteBySearch,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.urlRedirectBulkDeleteBySearch?.job?.id ?? "");
+    (0, import_output.printJson)(
+      {
+        job: result.urlRedirectBulkDeleteBySearch?.job ?? null,
+        count: countResult?.urlRedirectsCount ?? null,
+        search,
+        userErrors: result.urlRedirectBulkDeleteBySearch?.userErrors ?? []
+      },
+      ctx.format !== "raw"
+    );
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "UrlRedirect");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "url-redirects",
+      view: ctx.view,
+      baseSelection: getUrlRedirectSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { urlRedirect: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.urlRedirect, 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: "url-redirects",
+      view: ctx.view,
+      baseSelection: getUrlRedirectSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      urlRedirects: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.urlRedirects,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("url-redirects", { 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, {
+      urlRedirectCreate: {
+        __args: { urlRedirect: built.input },
+        urlRedirect: urlRedirectSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.urlRedirectCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.urlRedirectCreate?.urlRedirect?.id ?? "");
+    (0, import_output.printJson)(result.urlRedirectCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "UrlRedirect");
+    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, {
+      urlRedirectUpdate: {
+        __args: { id, urlRedirect: built.input },
+        urlRedirect: urlRedirectSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.urlRedirectUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.urlRedirectUpdate?.urlRedirect?.id ?? "");
+    (0, import_output.printJson)(result.urlRedirectUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "UrlRedirect");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      urlRedirectDelete: {
+        __args: { id },
+        deletedUrlRedirectId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.urlRedirectDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.urlRedirectDelete?.deletedUrlRedirectId ?? "");
+    (0, import_output.printJson)(result.urlRedirectDelete, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for url-redirects: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runUrlRedirects
+});
+//# sourceMappingURL=url-redirects.js.map