shop-cli 0.1.0

package/dist/cli/verbs/point-of-sale.js

@@ -0,0 +1,57 @@
+"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 point_of_sale_exports = {};
+__export(point_of_sale_exports, {
+  runPointOfSale: () => runPointOfSale
+});
+module.exports = __toCommonJS(point_of_sale_exports);
+var import_errors = require("../errors");
+var import_output = require("../output");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_shared = require("./_shared");
+const deviceSelection = {
+  id: true
+};
+const runPointOfSale = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (verb !== "get") throw new import_errors.CliError(`Unknown verb for point-of-sale: ${verb}`, 2);
+  const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+  const id = (0, import_shared.requireId)(args.id, "PointOfSaleDevice");
+  const selection = (0, import_select.resolveSelection)({
+    resource: "point-of-sale",
+    view: ctx.view,
+    baseSelection: deviceSelection,
+    select: args.select,
+    selection: args.selection,
+    include: args.include,
+    ensureId: ctx.quiet
+  });
+  const result = await (0, import_router.runQuery)(ctx, { pointOfSaleDevice: { __args: { id }, ...selection } });
+  if (result === void 0) return;
+  (0, import_output.printNode)({ node: result.pointOfSaleDevice, format: ctx.format, quiet: ctx.quiet });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runPointOfSale
+});
+//# sourceMappingURL=point-of-sale.js.map

package/dist/cli/verbs/price-lists.d.ts

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

package/dist/cli/verbs/price-lists.js

@@ -0,0 +1,426 @@
+"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 price_lists_exports = {};
+__export(price_lists_exports, {
+  runPriceLists: () => runPriceLists
+});
+module.exports = __toCommonJS(price_lists_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 priceListSummarySelection = {
+  id: true,
+  name: true,
+  currency: true,
+  catalog: { id: true, title: true },
+  parent: {
+    adjustment: {
+      type: true,
+      value: true
+    }
+  },
+  fixedPricesCount: true
+};
+const priceListFullSelection = {
+  ...priceListSummarySelection,
+  prices: {
+    __args: { first: 10 },
+    nodes: {
+      variant: { id: true, displayName: true },
+      price: { amount: true, currencyCode: true },
+      compareAtPrice: { amount: true, currencyCode: true },
+      originType: true
+    },
+    pageInfo: { hasNextPage: true, endCursor: true }
+  },
+  quantityRules: {
+    __args: { first: 10 },
+    nodes: {
+      productVariant: { id: true, displayName: true },
+      minimum: true,
+      maximum: true,
+      increment: true,
+      originType: true
+    },
+    pageInfo: { hasNextPage: true, endCursor: true }
+  }
+};
+const getPriceListSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return priceListFullSelection;
+  if (view === "raw") return {};
+  return priceListSummarySelection;
+};
+const ensureInput = (built) => {
+  if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+  return built.input;
+};
+const extractArrayField = (input, field) => {
+  if (Array.isArray(input)) return input;
+  if (input && Array.isArray(input[field])) return input[field];
+  return void 0;
+};
+const hasListArg = (value) => Array.isArray(value) ? value.length > 0 : value !== void 0;
+const runPriceLists = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop price-lists <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|update|delete",
+        "  add-prices|update-prices|update-prices-by-product|delete-prices",
+        "  add-quantity-rules|delete-quantity-rules|update-quantity-pricing",
+        "",
+        "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)",
+        "",
+        "Notes:",
+        "  --variant-ids <gid,gid,...> applies to delete-prices/delete-quantity-rules.",
+        "  --product-id <gid> can be used with update-prices-by-product to target a single product.",
+        "  delete operations require --yes."
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "PriceList");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "price-lists",
+      view: ctx.view,
+      baseSelection: getPriceListSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { priceList: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.priceList, 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 reverse = args.reverse;
+    const sortKey = args.sort;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "price-lists",
+      view: ctx.view,
+      baseSelection: getPriceListSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      priceLists: {
+        __args: { first, after, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.priceLists,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("price-lists", { first, 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"]
+    });
+    const input = ensureInput(built);
+    const result = await (0, import_router.runMutation)(ctx, {
+      priceListCreate: {
+        __args: { input },
+        priceList: priceListSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.priceListCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.priceListCreate?.priceList?.id ?? "");
+    (0, import_output.printJson)(result.priceListCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "PriceList");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = ensureInput(built);
+    const result = await (0, import_router.runMutation)(ctx, {
+      priceListUpdate: {
+        __args: { id, input },
+        priceList: priceListSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.priceListUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.priceListUpdate?.priceList?.id ?? "");
+    (0, import_output.printJson)(result.priceListUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "PriceList");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      priceListDelete: {
+        __args: { id },
+        deletedId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.priceListDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.priceListDelete?.deletedId ?? "");
+    (0, import_output.printJson)(result.priceListDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "add-prices") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const priceListId = (0, import_shared.requireId)(args.id, "PriceList");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = ensureInput(built);
+    const prices = extractArrayField(input, "prices");
+    if (!prices) throw new import_errors.CliError("Expected prices array via --input or --set prices[0].*", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      priceListFixedPricesAdd: {
+        __args: { priceListId, prices },
+        prices: { variant: { id: true }, price: { amount: true, currencyCode: true } },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.priceListFixedPricesAdd, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      const ids = (result.priceListFixedPricesAdd?.prices ?? []).map((p) => p?.variant?.id);
+      (0, import_output.printIds)(ids);
+      return;
+    }
+    (0, import_output.printJson)(result.priceListFixedPricesAdd, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update-prices") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "variant-ids": { type: "string", multiple: true } } });
+    const priceListId = (0, import_shared.requireId)(args.id, "PriceList");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = ensureInput(built);
+    const pricesToAdd = input.pricesToAdd ?? input.prices ?? (Array.isArray(input) ? input : []);
+    const rawVariantIds = args["variant-ids"];
+    const variantIdsToDelete = input.variantIdsToDelete ?? (hasListArg(rawVariantIds) ? (0, import_shared.parseIds)(rawVariantIds, "ProductVariant") : []);
+    if ((pricesToAdd?.length ?? 0) === 0 && (variantIdsToDelete?.length ?? 0) === 0) {
+      throw new import_errors.CliError("Expected pricesToAdd and/or variantIdsToDelete", 2);
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      priceListFixedPricesUpdate: {
+        __args: { priceListId, pricesToAdd, variantIdsToDelete },
+        priceList: { id: true },
+        pricesAdded: { variant: { id: true }, price: { amount: true, currencyCode: true } },
+        deletedFixedPriceVariantIds: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.priceListFixedPricesUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.priceListFixedPricesUpdate?.priceList?.id ?? "");
+    (0, import_output.printJson)(result.priceListFixedPricesUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update-prices-by-product") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const priceListId = (0, import_shared.requireId)(args.id, "PriceList");
+    const productId = args["product-id"];
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = ensureInput(built);
+    let pricesToAdd = input.pricesToAdd;
+    let pricesToDeleteByProductIds = input.pricesToDeleteByProductIds;
+    if (!pricesToAdd && !pricesToDeleteByProductIds && productId) {
+      const gid = (0, import_gid.coerceGid)(productId, "Product");
+      if (Array.isArray(input)) {
+        pricesToAdd = input.map((p) => ({ ...p, productId: p.productId ?? gid }));
+      } else {
+        const base = typeof input === "object" && input !== null ? input : {};
+        pricesToAdd = [{ ...base, productId: gid }];
+      }
+    }
+    if ((pricesToAdd?.length ?? 0) === 0 && (pricesToDeleteByProductIds?.length ?? 0) === 0) {
+      throw new import_errors.CliError("Expected pricesToAdd and/or pricesToDeleteByProductIds", 2);
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      priceListFixedPricesByProductUpdate: {
+        __args: { priceListId, pricesToAdd, pricesToDeleteByProductIds },
+        priceList: { id: true },
+        pricesToAddProducts: { id: true },
+        pricesToDeleteProducts: { id: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.priceListFixedPricesByProductUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(result.priceListFixedPricesByProductUpdate?.priceList?.id ?? "");
+    (0, import_output.printJson)(result.priceListFixedPricesByProductUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete-prices") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "variant-ids": { type: "string", multiple: true } } });
+    const priceListId = (0, import_shared.requireId)(args.id, "PriceList");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete prices without --yes", 2);
+    const variantIds = (0, import_shared.parseIds)(args["variant-ids"], "ProductVariant");
+    const result = await (0, import_router.runMutation)(ctx, {
+      priceListFixedPricesDelete: {
+        __args: { priceListId, variantIds },
+        deletedFixedPriceVariantIds: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.priceListFixedPricesDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      (0, import_output.printIds)(result.priceListFixedPricesDelete?.deletedFixedPriceVariantIds ?? []);
+      return;
+    }
+    (0, import_output.printJson)(result.priceListFixedPricesDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "add-quantity-rules") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const priceListId = (0, import_shared.requireId)(args.id, "PriceList");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = ensureInput(built);
+    const quantityRules = extractArrayField(input, "quantityRules");
+    if (!quantityRules) throw new import_errors.CliError("Expected quantityRules array via --input or --set quantityRules[0].*", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      quantityRulesAdd: {
+        __args: { priceListId, quantityRules },
+        quantityRules: { productVariant: { id: true }, minimum: true, maximum: true, increment: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.quantityRulesAdd, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      const ids = (result.quantityRulesAdd?.quantityRules ?? []).map((r) => r?.productVariant?.id);
+      (0, import_output.printIds)(ids);
+      return;
+    }
+    (0, import_output.printJson)(result.quantityRulesAdd, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete-quantity-rules") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "variant-ids": { type: "string", multiple: true } } });
+    const priceListId = (0, import_shared.requireId)(args.id, "PriceList");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete quantity rules without --yes", 2);
+    const variantIds = (0, import_shared.parseIds)(args["variant-ids"], "ProductVariant");
+    const result = await (0, import_router.runMutation)(ctx, {
+      quantityRulesDelete: {
+        __args: { priceListId, variantIds },
+        deletedQuantityRulesVariantIds: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.quantityRulesDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      (0, import_output.printIds)(result.quantityRulesDelete?.deletedQuantityRulesVariantIds ?? []);
+      return;
+    }
+    (0, import_output.printJson)(result.quantityRulesDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update-quantity-pricing") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const priceListId = (0, import_shared.requireId)(args.id, "PriceList");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    const input = ensureInput(built);
+    const result = await (0, import_router.runMutation)(ctx, {
+      quantityPricingByVariantUpdate: {
+        __args: { priceListId, input },
+        productVariants: { id: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.quantityPricingByVariantUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) {
+      (0, import_output.printIds)((result.quantityPricingByVariantUpdate?.productVariants ?? []).map((v) => v?.id));
+      return;
+    }
+    (0, import_output.printJson)(result.quantityPricingByVariantUpdate, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for price-lists: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runPriceLists
+});
+//# sourceMappingURL=price-lists.js.map

package/dist/cli/verbs/product-feeds.d.ts

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

package/dist/cli/verbs/product-feeds.js

@@ -0,0 +1,187 @@
+"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 product_feeds_exports = {};
+__export(product_feeds_exports, {
+  runProductFeeds: () => runProductFeeds
+});
+module.exports = __toCommonJS(product_feeds_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 productFeedSummarySelection = {
+  id: true,
+  country: true,
+  language: true,
+  status: true
+};
+const productFeedFullSelection = {
+  ...productFeedSummarySelection
+};
+const getProductFeedSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return productFeedFullSelection;
+  if (view === "raw") return {};
+  return productFeedSummarySelection;
+};
+const runProductFeeds = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop product-feeds <verb> [flags]",
+        "",
+        "Verbs:",
+        "  get|list|create|delete|full-sync",
+        "",
+        "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, "ProductFeed");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "product-feeds",
+      view: ctx.view,
+      baseSelection: getProductFeedSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { productFeed: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.productFeed, 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 reverse = args.reverse;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "product-feeds",
+      view: ctx.view,
+      baseSelection: getProductFeedSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      productFeeds: {
+        __args: { first, after, reverse },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.productFeeds,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("product-feeds", { first, 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, {
+      productFeedCreate: {
+        __args: { input: built.input },
+        productFeed: productFeedSummarySelection,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productFeedCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productFeedCreate?.productFeed?.id ?? "");
+    (0, import_output.printJson)(result.productFeedCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "ProductFeed");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      productFeedDelete: {
+        __args: { id },
+        deletedId: true,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productFeedDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productFeedDelete?.deletedId ?? "");
+    (0, import_output.printJson)(result.productFeedDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "full-sync") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "updated-at-since": { type: "string" },
+        "before-updated-at": { type: "string" }
+      }
+    });
+    const id = (0, import_shared.requireId)(args.id, "ProductFeed");
+    const updatedAtSince = args["updated-at-since"] ? (0, import_shared.parseDateTime)(args["updated-at-since"], "--updated-at-since") : void 0;
+    const beforeUpdatedAt = args["before-updated-at"] ? (0, import_shared.parseDateTime)(args["before-updated-at"], "--before-updated-at") : void 0;
+    const result = await (0, import_router.runMutation)(ctx, {
+      productFullSync: {
+        __args: {
+          id,
+          ...updatedAtSince ? { updatedAtSince } : {},
+          ...beforeUpdatedAt ? { beforeUpdatedAt } : {}
+        },
+        id: true,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productFullSync, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productFullSync?.id ?? "");
+    (0, import_output.printJson)(result.productFullSync, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for product-feeds: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runProductFeeds
+});
+//# sourceMappingURL=product-feeds.js.map

package/dist/cli/verbs/product-variants.d.ts

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