shop-cli 0.1.0

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

@@ -0,0 +1,388 @@
+"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_variants_exports = {};
+__export(product_variants_exports, {
+  runProductVariants: () => runProductVariants
+});
+module.exports = __toCommonJS(product_variants_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_upsert = require("../workflows/productVariants/upsert");
+var import_shared = require("./_shared");
+const productVariantSummarySelection = {
+  id: true,
+  displayName: true,
+  sku: true,
+  price: true,
+  availableForSale: true
+};
+const productVariantFullSelection = {
+  ...productVariantSummarySelection,
+  barcode: true,
+  compareAtPrice: true,
+  inventoryQuantity: true,
+  product: { id: true, title: true },
+  inventoryItem: { id: true }
+};
+const getProductVariantSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return productVariantFullSelection;
+  if (view === "raw") return {};
+  return productVariantSummarySelection;
+};
+const resolveProductIdForVariant = async ({
+  ctx,
+  variantId
+}) => {
+  if (ctx.dryRun) {
+    throw new import_errors.CliError("--dry-run cannot resolve product ID from variant; pass --product-id", 2);
+  }
+  const result = await (0, import_router.runQuery)(ctx, {
+    productVariant: { __args: { id: variantId }, product: { id: true } }
+  });
+  const productId = result?.productVariant?.product?.id;
+  if (!productId) throw new import_errors.CliError("Could not resolve product ID for variant", 2);
+  return productId;
+};
+const resolveBulkVariantsInput = (input) => {
+  if (Array.isArray(input)) {
+    return { variants: input, media: void 0, strategy: void 0 };
+  }
+  if (input && Array.isArray(input.variants)) {
+    return { variants: input.variants, media: input.media, strategy: input.strategy };
+  }
+  throw new import_errors.CliError("--input must be a JSON array or an object with a variants array", 2);
+};
+const runProductVariants = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop product-variants <verb> [flags]",
+        "",
+        "Verbs:",
+        "  get|get-by-identifier|by-identifier|list|count",
+        "  bulk-create|bulk-update|bulk-delete|bulk-reorder",
+        "  append-media|detach-media",
+        "  join-selling-plans|leave-selling-plans",
+        "  update-relationships",
+        "  upsert",
+        "",
+        "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 === "by-identifier") verb = "get-by-identifier";
+  if (verb === "upsert") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "allow-partial-updates": { type: "boolean" },
+        strategy: { type: "string" }
+      }
+    });
+    const strategy = args.strategy;
+    if (strategy && !["DEFAULT", "PRESERVE_STANDALONE_VARIANT", "REMOVE_STANDALONE_VARIANT"].includes(strategy)) {
+      throw new import_errors.CliError(
+        `--strategy must be one of DEFAULT|PRESERVE_STANDALONE_VARIANT|REMOVE_STANDALONE_VARIANT. Got: ${strategy}`,
+        2
+      );
+    }
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const payload = await (0, import_upsert.upsertProductVariants)({
+      ctx,
+      productId: args["product-id"],
+      input: built.input,
+      allowPartialUpdates: Boolean(args["allow-partial-updates"]),
+      strategy
+    });
+    if (payload === void 0) return;
+    (0, import_output.printJson)(payload);
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "ProductVariant");
+    const selection = (0, import_select.resolveSelection)({
+      resource: "product-variants",
+      view: ctx.view,
+      baseSelection: getProductVariantSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { productVariant: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.productVariant, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "get-by-identifier") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "product-id": { type: "string" }, sku: { type: "string" }, barcode: { type: "string" } }
+    });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    let identifier = built.used ? built.input : void 0;
+    if (!identifier) {
+      const productId = (0, import_shared.requireId)(args["product-id"], "Product");
+      const sku = args.sku;
+      const barcode = args.barcode;
+      if (!sku && !barcode) throw new import_errors.CliError("Missing --sku or --barcode", 2);
+      identifier = { productId, ...sku ? { sku } : {}, ...barcode ? { barcode } : {} };
+    }
+    const selection = (0, import_select.resolveSelection)({
+      resource: "product-variants",
+      view: ctx.view,
+      baseSelection: getProductVariantSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { productVariantByIdentifier: { __args: { identifier }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.productVariantByIdentifier, 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: "product-variants",
+      view: ctx.view,
+      baseSelection: getProductVariantSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      productVariants: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.productVariants,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)("product-variants", { first, query, sort: sortKey, reverse })
+    });
+    return;
+  }
+  if (verb === "count") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const query = args.query;
+    const result = await (0, import_router.runQuery)(ctx, { productVariantsCount: { __args: { query }, count: true, precision: true } });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.productVariantsCount?.count ?? "");
+    (0, import_output.printJson)(result.productVariantsCount, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "bulk-create" || verb === "bulk-update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: { "product-id": { type: "string" }, "allow-partial-updates": { type: "boolean" } }
+    });
+    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
+    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);
+    if (verb === "bulk-create") {
+      const input2 = built.input;
+      const { variants: variants2, media: media2, strategy } = resolveBulkVariantsInput(input2);
+      const result2 = await (0, import_router.runMutation)(ctx, {
+        productVariantsBulkCreate: {
+          __args: { productId, ...media2 ? { media: media2 } : {}, ...strategy ? { strategy } : {}, variants: variants2 },
+          product: { id: true },
+          productVariants: { id: true },
+          userErrors: { field: true, message: true }
+        }
+      });
+      if (result2 === void 0) return;
+      (0, import_userErrors.maybeFailOnUserErrors)({ payload: result2.productVariantsBulkCreate, failOnUserErrors: ctx.failOnUserErrors });
+      (0, import_output.printJson)(result2.productVariantsBulkCreate, ctx.format !== "raw");
+      return;
+    }
+    const input = built.input;
+    const { variants, media } = resolveBulkVariantsInput(input);
+    const allowPartialUpdates = Boolean(args["allow-partial-updates"]);
+    const result = await (0, import_router.runMutation)(ctx, {
+      productVariantsBulkUpdate: {
+        __args: {
+          productId,
+          allowPartialUpdates,
+          ...media ? { media } : {},
+          variants
+        },
+        product: { id: true },
+        productVariants: { id: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productVariantsBulkUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printJson)(result.productVariantsBulkUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "bulk-delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" } } });
+    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
+    const variantsIds = (0, import_shared.parseIds)(args["variant-ids"] ?? args.ids, "ProductVariant");
+    const result = await (0, import_router.runMutation)(ctx, {
+      productVariantsBulkDelete: {
+        __args: { productId, variantsIds },
+        product: { id: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productVariantsBulkDelete, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printJson)(result.productVariantsBulkDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "bulk-reorder") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "product-id": { type: "string" }, positions: { type: "string" } } });
+    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
+    const positions = (0, import_shared.parseJsonArg)(args.positions, "--positions");
+    const result = await (0, import_router.runMutation)(ctx, {
+      productVariantsBulkReorder: {
+        __args: { productId, positions },
+        product: { id: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productVariantsBulkReorder, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printJson)(result.productVariantsBulkReorder, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "append-media" || verb === "detach-media") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "media-ids": { type: "string", multiple: true },
+        "variant-media": { type: "string" }
+      }
+    });
+    const variantId = (0, import_shared.requireId)(args.id, "ProductVariant");
+    const productId = args["product-id"] ? (0, import_shared.requireId)(args["product-id"], "Product") : await resolveProductIdForVariant({ ctx, variantId });
+    let variantMedia = void 0;
+    if (args["variant-media"]) {
+      variantMedia = (0, import_shared.parseJsonArg)(args["variant-media"], "--variant-media");
+    } else {
+      const mediaIds = (0, import_shared.parseStringList)(args["media-ids"], "--media-ids");
+      variantMedia = [{ variantId, mediaIds }];
+    }
+    const mutation = verb === "append-media" ? "productVariantAppendMedia" : "productVariantDetachMedia";
+    const result = await (0, import_router.runMutation)(ctx, {
+      [mutation]: {
+        __args: { productId, variantMedia },
+        product: { id: true },
+        productVariants: { id: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    const payload = result[mutation];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "join-selling-plans" || verb === "leave-selling-plans") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "group-ids": { type: "string", multiple: true } } });
+    const id = (0, import_shared.requireId)(args.id, "ProductVariant");
+    const sellingPlanGroupIds = (0, import_shared.parseIds)(args["group-ids"], "SellingPlanGroup");
+    const mutation = verb === "join-selling-plans" ? "productVariantJoinSellingPlanGroups" : "productVariantLeaveSellingPlanGroups";
+    const result = await (0, import_router.runMutation)(ctx, {
+      [mutation]: {
+        __args: { id, sellingPlanGroupIds },
+        productVariant: { id: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    const payload = result[mutation];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update-relationships") {
+    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, {
+      productVariantRelationshipBulkUpdate: {
+        __args: { input: built.input },
+        parentProductVariants: { id: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.productVariantRelationshipBulkUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    (0, import_output.printJson)(result.productVariantRelationshipBulkUpdate, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for product-variants: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runProductVariants
+});
+//# sourceMappingURL=product-variants.js.map

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

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