shop-cli 0.1.1

package/dist/cli/router.js

@@ -0,0 +1,480 @@
+"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 router_exports = {};
+__export(router_exports, {
+  parseStandardArgs: () => parseStandardArgs,
+  runCommand: () => runCommand,
+  runMutation: () => runMutation,
+  runQuery: () => runQuery
+});
+module.exports = __toCommonJS(router_exports);
+var import_node_util = require("node:util");
+var import_admin_2026_04 = require("../generated/admin-2026-04");
+var import_admin_2026_042 = require("../generated/admin-2026-04");
+var import_errors = require("./errors");
+var import_output = require("./output");
+var import_introspection = require("./introspection");
+var import_format = require("./introspection/format");
+var import_resources = require("./introspection/resources");
+var import_articles = require("./verbs/articles");
+var import_blogs = require("./verbs/blogs");
+var import_bulk_operations = require("./verbs/bulk-operations");
+var import_carrier_services = require("./verbs/carrier-services");
+var import_cart_transforms = require("./verbs/cart-transforms");
+var import_catalogs = require("./verbs/catalogs");
+var import_checkout_branding = require("./verbs/checkout-branding");
+var import_checkout_profiles = require("./verbs/checkout-profiles");
+var import_collections = require("./verbs/collections");
+var import_comments = require("./verbs/comments");
+var import_companies = require("./verbs/companies");
+var import_company_contacts = require("./verbs/company-contacts");
+var import_company_locations = require("./verbs/company-locations");
+var import_customer_payment_methods = require("./verbs/customer-payment-methods");
+var import_customer_privacy = require("./verbs/customer-privacy");
+var import_customer_segments = require("./verbs/customer-segments");
+var import_customers = require("./verbs/customers");
+var import_delegate_tokens = require("./verbs/delegate-tokens");
+var import_delivery_customizations = require("./verbs/delivery-customizations");
+var import_delivery_profile_locations = require("./verbs/delivery-profile-locations");
+var import_delivery_profiles = require("./verbs/delivery-profiles");
+var import_delivery_settings = require("./verbs/delivery-settings");
+var import_draft_orders = require("./verbs/draft-orders");
+var import_events = require("./verbs/events");
+var import_files = require("./verbs/files");
+var import_fulfillment_services = require("./verbs/fulfillment-services");
+var import_gift_cards = require("./verbs/gift-cards");
+var import_inventory_items = require("./verbs/inventory-items");
+var import_inventory_shipments = require("./verbs/inventory-shipments");
+var import_inventory_transfers = require("./verbs/inventory-transfers");
+var import_inventory = require("./verbs/inventory");
+var import_locations = require("./verbs/locations");
+var import_order_edit = require("./verbs/order-edit");
+var import_marketing_activities = require("./verbs/marketing-activities");
+var import_orders = require("./verbs/orders");
+var import_fulfillment_orders = require("./verbs/fulfillment-orders");
+var import_fulfillments = require("./verbs/fulfillments");
+var import_payment_terms = require("./verbs/payment-terms");
+var import_price_lists = require("./verbs/price-lists");
+var import_product_variants = require("./verbs/product-variants");
+var import_products = require("./verbs/products");
+var import_publications = require("./verbs/publications");
+var import_markets = require("./verbs/markets");
+var import_market_localizations = require("./verbs/market-localizations");
+var import_market_web_presences = require("./verbs/market-web-presences");
+var import_menus = require("./verbs/menus");
+var import_metafield_definitions = require("./verbs/metafield-definitions");
+var import_metaobject_definitions = require("./verbs/metaobject-definitions");
+var import_metaobjects = require("./verbs/metaobjects");
+var import_pages = require("./verbs/pages");
+var import_refunds = require("./verbs/refunds");
+var import_saved_searches = require("./verbs/saved-searches");
+var import_segments = require("./verbs/segments");
+var import_script_tags = require("./verbs/script-tags");
+var import_selling_plan_groups = require("./verbs/selling-plan-groups");
+var import_selling_plan_group_products = require("./verbs/selling-plan-group-products");
+var import_subscription_billing = require("./verbs/subscription-billing");
+var import_subscription_contracts = require("./verbs/subscription-contracts");
+var import_subscription_drafts = require("./verbs/subscription-drafts");
+var import_server_pixels = require("./verbs/server-pixels");
+var import_shop = require("./verbs/shop");
+var import_shopify_functions = require("./verbs/shopify-functions");
+var import_store_credit = require("./verbs/store-credit");
+var import_themes = require("./verbs/themes");
+var import_translations = require("./verbs/translations");
+var import_url_redirects = require("./verbs/url-redirects");
+var import_validations = require("./verbs/validations");
+var import_web_pixels = require("./verbs/web-pixels");
+var import_webhooks = require("./verbs/webhooks");
+var import_returns = require("./verbs/returns");
+var import_reverse_deliveries = require("./verbs/reverse-deliveries");
+var import_reverse_fulfillment_orders = require("./verbs/reverse-fulfillment-orders");
+var import_returnable_fulfillments = require("./verbs/returnable-fulfillments");
+var import_app_billing = require("./verbs/app-billing");
+var import_apps = require("./verbs/apps");
+var import_backup = require("./verbs/backup");
+var import_channels = require("./verbs/channels");
+var import_file_saved_searches = require("./verbs/file-saved-searches");
+var import_graphql = require("./verbs/graphql");
+var import_locales = require("./verbs/locales");
+var import_discounts_automatic = require("./verbs/discounts-automatic");
+var import_discounts_code = require("./verbs/discounts-code");
+var import_discount_nodes = require("./verbs/discount-nodes");
+var import_discount_redeem_codes = require("./verbs/discount-redeem-codes");
+var import_discount_saved_searches = require("./verbs/discount-saved-searches");
+var import_abandoned_checkouts = require("./verbs/abandoned-checkouts");
+var import_payment_customizations = require("./verbs/payment-customizations");
+var import_taxonomy = require("./verbs/taxonomy");
+var import_staff = require("./verbs/staff");
+var import_metafield_definition_tools = require("./verbs/metafield-definition-tools");
+var import_metafields = require("./verbs/metafields");
+var import_metaobject_definition_tools = require("./verbs/metaobject-definition-tools");
+var import_storefront_access_tokens = require("./verbs/storefront-access-tokens");
+var import_fulfillment_constraint_rules = require("./verbs/fulfillment-constraint-rules");
+var import_shopify_payments = require("./verbs/shopify-payments");
+var import_business_entities = require("./verbs/business-entities");
+var import_shop_policies = require("./verbs/shop-policies");
+var import_cash_tracking = require("./verbs/cash-tracking");
+var import_point_of_sale = require("./verbs/point-of-sale");
+var import_customer_account_pages = require("./verbs/customer-account-pages");
+var import_delivery_promises = require("./verbs/delivery-promises");
+var import_disputes = require("./verbs/disputes");
+var import_finance = require("./verbs/finance");
+var import_flow = require("./verbs/flow");
+var import_marketing_events = require("./verbs/marketing-events");
+var import_mobile_platform_applications = require("./verbs/mobile-platform-applications");
+var import_shipping_packages = require("./verbs/shipping-packages");
+var import_shop_utils = require("./verbs/shop-utils");
+var import_staged_uploads = require("./verbs/staged-uploads");
+var import_subscription_billing_cycles = require("./verbs/subscription-billing-cycles");
+var import_tender_transactions = require("./verbs/tender-transactions");
+var import_tags = require("./verbs/tags");
+var import_tax = require("./verbs/tax");
+var import_types = require("./verbs/types");
+var import_web_presences = require("./verbs/web-presences");
+var import_product_feeds = require("./verbs/product-feeds");
+var import_resource_feedback = require("./verbs/resource-feedback");
+var import_publishables = require("./verbs/publishables");
+const runCommand = async ({
+  client,
+  resource,
+  verb,
+  argv,
+  format,
+  quiet,
+  view,
+  dryRun,
+  failOnUserErrors,
+  warnMissingAccessToken,
+  shopDomain,
+  graphqlEndpoint,
+  accessToken,
+  apiVersion,
+  headers
+}) => {
+  (0, import_output.setGlobalOutputFormat)(format);
+  const ctx = {
+    client,
+    format,
+    quiet,
+    view,
+    dryRun,
+    failOnUserErrors,
+    warnMissingAccessToken,
+    shopDomain,
+    graphqlEndpoint,
+    accessToken,
+    apiVersion,
+    headers
+  };
+  if (verb === "fields") {
+    const typeName = import_resources.resourceToType[resource];
+    if (!typeName) {
+      throw new import_errors.CliError(`No field introspection available for resource: ${resource}`, 2);
+    }
+    const type = (0, import_introspection.getType)(typeName);
+    if (!type) {
+      throw new import_errors.CliError(`Unknown GraphQL type for resource "${resource}": ${typeName}`, 2);
+    }
+    const fields = (0, import_introspection.getFields)(typeName);
+    if (ctx.format === "json" || ctx.format === "raw" || ctx.format === "jsonl") {
+      const pretty = ctx.format === "json";
+      console.log(JSON.stringify({ resource, typeName, fields }, null, pretty ? 2 : 0));
+      return;
+    }
+    (0, import_format.printFieldsTable)({ resource, typeName, fields });
+    return;
+  }
+  if (resource === "products") return (0, import_products.runProducts)({ ctx, verb, argv });
+  if (resource === "product-variants") return (0, import_product_variants.runProductVariants)({ ctx, verb, argv });
+  if (resource === "product-feeds") return (0, import_product_feeds.runProductFeeds)({ ctx, verb, argv });
+  if (resource === "collections") return (0, import_collections.runCollections)({ ctx, verb, argv });
+  if (resource === "resource-feedback") return (0, import_resource_feedback.runResourceFeedback)({ ctx, verb, argv });
+  if (resource === "publishables") return (0, import_publishables.runPublishables)({ ctx, verb, argv });
+  if (resource === "customers") return (0, import_customers.runCustomers)({ ctx, verb, argv });
+  if (resource === "orders") return (0, import_orders.runOrders)({ ctx, verb, argv });
+  if (resource === "order-edit") return (0, import_order_edit.runOrderEdit)({ ctx, verb, argv });
+  if (resource === "inventory") return (0, import_inventory.runInventory)({ ctx, verb, argv });
+  if (resource === "abandoned-checkouts") return (0, import_abandoned_checkouts.runAbandonedCheckouts)({ ctx, verb, argv });
+  if (resource === "returns") return (0, import_returns.runReturns)({ ctx, verb, argv });
+  if (resource === "fulfillment-orders") return (0, import_fulfillment_orders.runFulfillmentOrders)({ ctx, verb, argv });
+  if (resource === "fulfillments") return (0, import_fulfillments.runFulfillments)({ ctx, verb, argv });
+  if (resource === "fulfillment-services") return (0, import_fulfillment_services.runFulfillmentServices)({ ctx, verb, argv });
+  if (resource === "fulfillment-constraint-rules") return (0, import_fulfillment_constraint_rules.runFulfillmentConstraintRules)({ ctx, verb, argv });
+  if (resource === "inventory-items") return (0, import_inventory_items.runInventoryItems)({ ctx, verb, argv });
+  if (resource === "inventory-shipments") return (0, import_inventory_shipments.runInventoryShipments)({ ctx, verb, argv });
+  if (resource === "inventory-transfers") return (0, import_inventory_transfers.runInventoryTransfers)({ ctx, verb, argv });
+  if (resource === "files") return (0, import_files.runFiles)({ ctx, verb, argv });
+  if (resource === "locations") return (0, import_locations.runLocations)({ ctx, verb, argv });
+  if (resource === "staff") return (0, import_staff.runStaff)({ ctx, verb, argv });
+  if (resource === "storefront-access-tokens") return (0, import_storefront_access_tokens.runStorefrontAccessTokens)({ ctx, verb, argv });
+  if (resource === "gift-cards") return (0, import_gift_cards.runGiftCards)({ ctx, verb, argv });
+  if (resource === "discounts-automatic") return (0, import_discounts_automatic.runDiscountsAutomatic)({ ctx, verb, argv });
+  if (resource === "discounts-code") return (0, import_discounts_code.runDiscountsCode)({ ctx, verb, argv });
+  if (resource === "discount-nodes") return (0, import_discount_nodes.runDiscountNodes)({ ctx, verb, argv });
+  if (resource === "discount-redeem-codes") return (0, import_discount_redeem_codes.runDiscountRedeemCodes)({ ctx, verb, argv });
+  if (resource === "discount-saved-searches") return (0, import_discount_saved_searches.runDiscountSavedSearches)({ ctx, verb, argv });
+  if (resource === "payment-customizations") return (0, import_payment_customizations.runPaymentCustomizations)({ ctx, verb, argv });
+  if (resource === "price-lists") return (0, import_price_lists.runPriceLists)({ ctx, verb, argv });
+  if (resource === "refunds") return (0, import_refunds.runRefunds)({ ctx, verb, argv });
+  if (resource === "payment-terms") return (0, import_payment_terms.runPaymentTerms)({ ctx, verb, argv });
+  if (resource === "taxonomy") return (0, import_taxonomy.runTaxonomy)({ ctx, verb, argv });
+  if (resource === "shopify-payments") return (0, import_shopify_payments.runShopifyPayments)({ ctx, verb, argv });
+  if (resource === "business-entities") return (0, import_business_entities.runBusinessEntities)({ ctx, verb, argv });
+  if (resource === "shop-policies") return (0, import_shop_policies.runShopPolicies)({ ctx, verb, argv });
+  if (resource === "cash-tracking") return (0, import_cash_tracking.runCashTracking)({ ctx, verb, argv });
+  if (resource === "point-of-sale") return (0, import_point_of_sale.runPointOfSale)({ ctx, verb, argv });
+  if (resource === "customer-account-pages") return (0, import_customer_account_pages.runCustomerAccountPages)({ ctx, verb, argv });
+  if (resource === "publications") return (0, import_publications.runPublications)({ ctx, verb, argv });
+  if (resource === "articles") return (0, import_articles.runArticles)({ ctx, verb, argv });
+  if (resource === "blogs") return (0, import_blogs.runBlogs)({ ctx, verb, argv });
+  if (resource === "pages") return (0, import_pages.runPages)({ ctx, verb, argv });
+  if (resource === "comments") return (0, import_comments.runComments)({ ctx, verb, argv });
+  if (resource === "menus") return (0, import_menus.runMenus)({ ctx, verb, argv });
+  if (resource === "catalogs") return (0, import_catalogs.runCatalogs)({ ctx, verb, argv });
+  if (resource === "markets") return (0, import_markets.runMarkets)({ ctx, verb, argv });
+  if (resource === "market-localizations") return (0, import_market_localizations.runMarketLocalizations)({ ctx, verb, argv });
+  if (resource === "market-web-presences") return (0, import_market_web_presences.runMarketWebPresences)({ ctx, verb, argv });
+  if (resource === "draft-orders") return (0, import_draft_orders.runDraftOrders)({ ctx, verb, argv });
+  if (resource === "url-redirects") return (0, import_url_redirects.runUrlRedirects)({ ctx, verb, argv });
+  if (resource === "segments") return (0, import_segments.runSegments)({ ctx, verb, argv });
+  if (resource === "saved-searches") return (0, import_saved_searches.runSavedSearches)({ ctx, verb, argv });
+  if (resource === "script-tags") return (0, import_script_tags.runScriptTags)({ ctx, verb, argv });
+  if (resource === "carrier-services") return (0, import_carrier_services.runCarrierServices)({ ctx, verb, argv });
+  if (resource === "webhooks") return (0, import_webhooks.runWebhooks)({ ctx, verb, argv });
+  if (resource === "subscription-contracts") return (0, import_subscription_contracts.runSubscriptionContracts)({ ctx, verb, argv });
+  if (resource === "subscription-billing") return (0, import_subscription_billing.runSubscriptionBilling)({ ctx, verb, argv });
+  if (resource === "subscription-billing-cycles") return (0, import_subscription_billing_cycles.runSubscriptionBillingCycles)({ ctx, verb, argv });
+  if (resource === "subscription-drafts") return (0, import_subscription_drafts.runSubscriptionDrafts)({ ctx, verb, argv });
+  if (resource === "metafield-definitions") return (0, import_metafield_definitions.runMetafieldDefinitions)({ ctx, verb, argv });
+  if (resource === "metaobjects") return (0, import_metaobjects.runMetaobjects)({ ctx, verb, argv });
+  if (resource === "metaobject-definitions") return (0, import_metaobject_definitions.runMetaobjectDefinitions)({ ctx, verb, argv });
+  if (resource === "selling-plan-groups") return (0, import_selling_plan_groups.runSellingPlanGroups)({ ctx, verb, argv });
+  if (resource === "selling-plan-group-products") return (0, import_selling_plan_group_products.runSellingPlanGroupProducts)({ ctx, verb, argv });
+  if (resource === "companies") return (0, import_companies.runCompanies)({ ctx, verb, argv });
+  if (resource === "company-contacts") return (0, import_company_contacts.runCompanyContacts)({ ctx, verb, argv });
+  if (resource === "company-locations") return (0, import_company_locations.runCompanyLocations)({ ctx, verb, argv });
+  if (resource === "customer-privacy") return (0, import_customer_privacy.runCustomerPrivacy)({ ctx, verb, argv });
+  if (resource === "customer-payment-methods") return (0, import_customer_payment_methods.runCustomerPaymentMethods)({ ctx, verb, argv });
+  if (resource === "customer-segments") return (0, import_customer_segments.runCustomerSegments)({ ctx, verb, argv });
+  if (resource === "store-credit") return (0, import_store_credit.runStoreCredit)({ ctx, verb, argv });
+  if (resource === "delegate-tokens") return (0, import_delegate_tokens.runDelegateTokens)({ ctx, verb, argv });
+  if (resource === "themes") return (0, import_themes.runThemes)({ ctx, verb, argv });
+  if (resource === "cart-transforms") return (0, import_cart_transforms.runCartTransforms)({ ctx, verb, argv });
+  if (resource === "validations") return (0, import_validations.runValidations)({ ctx, verb, argv });
+  if (resource === "checkout-branding") return (0, import_checkout_branding.runCheckoutBranding)({ ctx, verb, argv });
+  if (resource === "checkout-profiles") return (0, import_checkout_profiles.runCheckoutProfiles)({ ctx, verb, argv });
+  if (resource === "delivery-profiles") return (0, import_delivery_profiles.runDeliveryProfiles)({ ctx, verb, argv });
+  if (resource === "delivery-customizations") return (0, import_delivery_customizations.runDeliveryCustomizations)({ ctx, verb, argv });
+  if (resource === "delivery-promises") return (0, import_delivery_promises.runDeliveryPromises)({ ctx, verb, argv });
+  if (resource === "delivery-settings") return (0, import_delivery_settings.runDeliverySettings)({ ctx, verb, argv });
+  if (resource === "delivery-profile-locations") return (0, import_delivery_profile_locations.runDeliveryProfileLocations)({ ctx, verb, argv });
+  if (resource === "shipping-packages") return (0, import_shipping_packages.runShippingPackages)({ ctx, verb, argv });
+  if (resource === "mobile-platform-applications") return (0, import_mobile_platform_applications.runMobilePlatformApplications)({ ctx, verb, argv });
+  if (resource === "tax") return (0, import_tax.runTax)({ ctx, verb, argv });
+  if (resource === "tags") return (0, import_tags.runTags)({ ctx, verb, argv });
+  if (resource === "flow") return (0, import_flow.runFlow)({ ctx, verb, argv });
+  if (resource === "disputes") return (0, import_disputes.runDisputes)({ ctx, verb, argv });
+  if (resource === "finance") return (0, import_finance.runFinance)({ ctx, verb, argv });
+  if (resource === "marketing-events") return (0, import_marketing_events.runMarketingEvents)({ ctx, verb, argv });
+  if (resource === "tender-transactions") return (0, import_tender_transactions.runTenderTransactions)({ ctx, verb, argv });
+  if (resource === "web-pixels") return (0, import_web_pixels.runWebPixels)({ ctx, verb, argv });
+  if (resource === "server-pixels") return (0, import_server_pixels.runServerPixels)({ ctx, verb, argv });
+  if (resource === "marketing-activities") return (0, import_marketing_activities.runMarketingActivities)({ ctx, verb, argv });
+  if (resource === "bulk-operations") return (0, import_bulk_operations.runBulkOperations)({ ctx, verb, argv });
+  if (resource === "app-billing") return (0, import_app_billing.runAppBilling)({ ctx, verb, argv });
+  if (resource === "apps") return (0, import_apps.runApps)({ ctx, verb, argv });
+  if (resource === "backup") return (0, import_backup.runBackup)({ ctx, verb, argv });
+  if (resource === "channels") return (0, import_channels.runChannels)({ ctx, verb, argv });
+  if (resource === "config") return (0, import_shop.runShopConfig)({ ctx, verb, argv });
+  if (resource === "file-saved-searches") return (0, import_file_saved_searches.runFileSavedSearches)({ ctx, verb, argv });
+  if (resource === "locales") return (0, import_locales.runLocales)({ ctx, verb, argv });
+  if (resource === "metafield-definition-tools") return (0, import_metafield_definition_tools.runMetafieldDefinitionTools)({ ctx, verb, argv });
+  if (resource === "metaobject-definition-tools") return (0, import_metaobject_definition_tools.runMetaobjectDefinitionTools)({ ctx, verb, argv });
+  if (resource === "metafields") return (0, import_metafields.runMetafields)({ ctx, verb, argv });
+  if (resource === "shop") return (0, import_shop_utils.runShop)({ ctx, verb, argv });
+  if (resource === "staged-uploads") return (0, import_staged_uploads.runStagedUploads)({ ctx, verb, argv });
+  if (resource === "web-presences") return (0, import_web_presences.runWebPresences)({ ctx, verb, argv });
+  if (resource === "translations") return (0, import_translations.runTranslations)({ ctx, verb, argv });
+  if (resource === "events") return (0, import_events.runEvents)({ ctx, verb, argv });
+  if (resource === "functions") return (0, import_shopify_functions.runShopifyFunctions)({ ctx, verb, argv });
+  if (resource === "graphql") return (0, import_graphql.runGraphQL)({ ctx, verb, argv });
+  if (resource === "types") return (0, import_types.runTypes)({ verb, argv });
+  if (resource === "returnable-fulfillments") return (0, import_returnable_fulfillments.runReturnableFulfillments)({ ctx, verb, argv });
+  if (resource === "reverse-deliveries") return (0, import_reverse_deliveries.runReverseDeliveries)({ ctx, verb, argv });
+  if (resource === "reverse-fulfillment-orders") return (0, import_reverse_fulfillment_orders.runReverseFulfillmentOrders)({ ctx, verb, argv });
+  throw new import_errors.CliError(`Unknown resource: ${resource}`, 2);
+};
+const hasNotAuthorizedError = (err) => err.errors.some(
+  (error) => typeof error?.message === "string" && error.message.toLowerCase().includes("not authorized")
+);
+const isAccessDeniedError = (error) => typeof error?.extensions?.code === "string" && error.extensions.code === "ACCESS_DENIED";
+const normalizeErrorPath = (path) => {
+  if (!Array.isArray(path)) return [];
+  return path.filter((p) => typeof p === "string");
+};
+const hasAnySelectedFields = (selection) => Object.keys(selection).some((k) => k !== "__args");
+const deleteSelectionAtPath = (root, path) => {
+  if (path.length === 0) return false;
+  const stack = [];
+  let cursor = root;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    const next = cursor?.[key];
+    if (typeof next !== "object" || next === null || Array.isArray(next)) return false;
+    stack.push({ parent: cursor, key, node: next });
+    cursor = next;
+  }
+  const leafKey = path[path.length - 1];
+  if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) return false;
+  if (!(leafKey in cursor)) return false;
+  delete cursor[leafKey];
+  let child = cursor;
+  for (let i = stack.length - 1; i >= 0; i--) {
+    if (hasAnySelectedFields(child)) break;
+    const { parent, key } = stack[i];
+    delete parent[key];
+    child = parent;
+  }
+  return true;
+};
+const pruneAccessDeniedFields = (request, errors, pruned) => {
+  let changed = false;
+  for (const error of errors) {
+    if (!isAccessDeniedError(error)) continue;
+    const path = normalizeErrorPath(error.path);
+    if (path.length === 0) continue;
+    const removed = deleteSelectionAtPath(request, path);
+    if (!removed) continue;
+    const requiredAccess = typeof error?.extensions?.requiredAccess === "string" ? error.extensions.requiredAccess : void 0;
+    pruned.set(path.join("."), requiredAccess);
+    changed = true;
+  }
+  return changed;
+};
+const runWithAccessDeniedPruning = async (ctx, request, op) => {
+  const pruned = /* @__PURE__ */ new Map();
+  let lastGenqlError;
+  for (let attempt = 0; attempt < 10; attempt++) {
+    try {
+      const result = op === "query" ? await ctx.client.query(request) : await ctx.client.mutation(request);
+      if (!ctx.quiet && pruned.size > 0) {
+        const details = Array.from(pruned.entries()).map(
+          ([path, requiredAccess]) => requiredAccess ? `${path} (${requiredAccess})` : path
+        ).join(", ");
+        console.error(`Omitted ${pruned.size} access-denied field(s): ${details}`);
+      }
+      return result;
+    } catch (err) {
+      if (!(err instanceof import_admin_2026_042.GenqlError)) throw err;
+      lastGenqlError = err;
+      const changed = pruneAccessDeniedFields(request, err.errors, pruned);
+      if (!changed) throw err;
+      if (typeof request !== "object" || request === null || Object.keys(request).length === 0) {
+        throw err;
+      }
+    }
+  }
+  if (lastGenqlError) throw lastGenqlError;
+  throw new Error("Internal error: pruning retry loop exhausted without an error");
+};
+const parseStandardArgs = ({
+  argv,
+  extraOptions
+}) => {
+  const parsed = (0, import_node_util.parseArgs)({
+    args: argv,
+    allowPositionals: false,
+    options: {
+      ...extraOptions,
+      input: { type: "string" },
+      set: { type: "string", multiple: true },
+      "set-json": { type: "string", multiple: true },
+      select: { type: "string", multiple: true },
+      selection: { type: "string" },
+      include: { type: "string", multiple: true },
+      id: { type: "string" },
+      ids: { type: "string", multiple: true },
+      yes: { type: "boolean" },
+      help: { type: "boolean" },
+      h: { type: "boolean" },
+      query: { type: "string" },
+      first: { type: "string" },
+      after: { type: "string" },
+      sort: { type: "string" },
+      reverse: { type: "boolean" },
+      type: { type: "string" },
+      key: { type: "string" },
+      namespace: { type: "string" },
+      topic: { type: "string" },
+      "owner-type": { type: "string" },
+      "order-id": { type: "string" },
+      "variant-ids": { type: "string", multiple: true },
+      tags: { type: "string" },
+      status: { type: "string" },
+      "new-title": { type: "string" }
+    }
+  });
+  return parsed.values;
+};
+const runQuery = async (ctx, request) => {
+  if (ctx.dryRun) {
+    console.log(JSON.stringify((0, import_admin_2026_04.generateQueryOp)(request), null, 2));
+    return void 0;
+  }
+  try {
+    if (ctx.view === "all") return await runWithAccessDeniedPruning(ctx, request, "query");
+    return await ctx.client.query(request);
+  } catch (err) {
+    if (err instanceof import_admin_2026_042.GenqlError) {
+      if (ctx.warnMissingAccessToken && hasNotAuthorizedError(err)) {
+        console.error("SHOPIFY_ACCESS_TOKEN not set");
+      }
+      (0, import_output.printJsonError)({ errors: err.errors, data: err.data });
+      throw new import_errors.CliError("GraphQL query failed", 1);
+    }
+    throw err;
+  }
+};
+const runMutation = async (ctx, request) => {
+  if (ctx.dryRun) {
+    console.log(JSON.stringify((0, import_admin_2026_04.generateMutationOp)(request), null, 2));
+    return void 0;
+  }
+  try {
+    if (ctx.view === "all") return await runWithAccessDeniedPruning(ctx, request, "mutation");
+    return await ctx.client.mutation(request);
+  } catch (err) {
+    if (err instanceof import_admin_2026_042.GenqlError) {
+      if (ctx.warnMissingAccessToken && hasNotAuthorizedError(err)) {
+        console.error("SHOPIFY_ACCESS_TOKEN not set");
+      }
+      (0, import_output.printJsonError)({ errors: err.errors, data: err.data });
+      throw new import_errors.CliError("GraphQL mutation failed", 1);
+    }
+    throw err;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseStandardArgs,
+  runCommand,
+  runMutation,
+  runQuery
+});
+//# sourceMappingURL=router.js.map

package/dist/cli/selection/buildAllSelection.d.ts

@@ -0,0 +1,13 @@
+import type { GenqlSelection } from './graphqlSelection';
+/**
+ * Validate that all --include targets are valid connection fields without required args.
+ * Throws CliError if any are invalid.
+ */
+export declare const validateIncludes: (typeName: string, includes: string[]) => void;
+/**
+ * Build a selection that includes all scalar fields and nested object fields.
+ * Skips connections and fields with required arguments.
+ *
+ * Connections are only included if explicitly requested via includeConnections.
+ */
+export declare const buildAllSelection: (typeName: string, includeConnections?: string[], depth?: number, maxDepth?: number, visited?: Set<string>, defaultConnectionFirst?: number) => GenqlSelection;

package/dist/cli/selection/buildAllSelection.js

@@ -0,0 +1,108 @@
+"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 buildAllSelection_exports = {};
+__export(buildAllSelection_exports, {
+  buildAllSelection: () => buildAllSelection,
+  validateIncludes: () => validateIncludes
+});
+module.exports = __toCommonJS(buildAllSelection_exports);
+var import_errors = require("../errors");
+var import_introspection = require("../introspection");
+var import_deprecations = require("../introspection/deprecations");
+const hasAnySelectedFields = (selection) => Object.keys(selection).filter((k) => k !== "__args" && k !== "__directives" && k !== "__name").length > 0;
+const getConnectionNodeTypeName = (connectionTypeName) => {
+  const connectionType = (0, import_introspection.getType)(connectionTypeName);
+  const nodesTypeName = connectionType?.fields?.nodes?.type?.name;
+  if (nodesTypeName) return nodesTypeName;
+  const edgesTypeName = connectionType?.fields?.edges?.type?.name;
+  if (!edgesTypeName) return void 0;
+  const edgesType = (0, import_introspection.getType)(edgesTypeName);
+  return edgesType?.fields?.node?.type?.name;
+};
+const validateIncludes = (typeName, includes) => {
+  const fields = (0, import_introspection.getFields)(typeName);
+  const fieldMap = new Map(fields.map((f) => [f.name, f]));
+  for (const name of includes) {
+    const field = fieldMap.get(name);
+    if (!field) {
+      throw new import_errors.CliError(`Unknown field: ${name}`, 2);
+    }
+    if (!field.isConnection) {
+      throw new import_errors.CliError(`Field "${name}" is not a connection field. Use --select for non-connection fields.`, 2);
+    }
+    if (field.hasRequiredArgs) {
+      throw new import_errors.CliError(`Connection "${name}" has required arguments and cannot be used with --include.`, 2);
+    }
+  }
+};
+const buildAllSelection = (typeName, includeConnections = [], depth = 0, maxDepth = 2, visited = /* @__PURE__ */ new Set(), defaultConnectionFirst = 10) => {
+  const type = (0, import_introspection.getType)(typeName);
+  if (!type) throw new import_errors.CliError(`Unknown GraphQL type: ${typeName}`, 2);
+  if (visited.has(typeName) || depth > maxDepth) {
+    return {};
+  }
+  visited.add(typeName);
+  const fields = (0, import_introspection.getFields)(typeName);
+  const selection = {};
+  for (const field of fields) {
+    if (field.hasRequiredArgs) continue;
+    if ((0, import_deprecations.isDeprecatedField)(typeName, field.name)) continue;
+    if (field.isConnection) {
+      if (!includeConnections.includes(field.name)) continue;
+      const nodeTypeName = getConnectionNodeTypeName(field.typeName);
+      if (!nodeTypeName) continue;
+      const nodesSelection = buildAllSelection(
+        nodeTypeName,
+        [],
+        depth + 1,
+        maxDepth,
+        new Set(visited),
+        defaultConnectionFirst
+      );
+      if (!hasAnySelectedFields(nodesSelection)) continue;
+      selection[field.name] = {
+        __args: { first: defaultConnectionFirst },
+        ...(0, import_introspection.getType)(field.typeName)?.fields?.nodes ? { nodes: nodesSelection } : { edges: { node: nodesSelection } },
+        pageInfo: { hasNextPage: true, endCursor: true }
+      };
+      continue;
+    }
+    if (field.isScalar) {
+      selection[field.name] = true;
+      continue;
+    }
+    const nested = buildAllSelection(
+      field.typeName,
+      [],
+      depth + 1,
+      maxDepth,
+      new Set(visited),
+      defaultConnectionFirst
+    );
+    if (!hasAnySelectedFields(nested)) continue;
+    selection[field.name] = nested;
+  }
+  return selection;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAllSelection,
+  validateIncludes
+});
+//# sourceMappingURL=buildAllSelection.js.map

package/dist/cli/selection/graphqlSelection.d.ts

@@ -0,0 +1,5 @@
+export type GenqlSelection = {
+    __args?: Record<string, unknown>;
+    [field: string]: true | GenqlSelection | Record<string, unknown> | undefined;
+};
+export declare const parseGraphqlSelectionArg: (arg: string) => GenqlSelection;